def workbench():
"""Create a workbench and register basic manifests.
"""
workbench = Workbench()
workbench.register(CoreManifest())
workbench.register(ErrorsManifest())
return workbench
def test_registration(windows):
"""Test that the manifest is properly regsistered.
"""
w = Workbench()
w.register(CoreManifest())
w.register(ErrorsManifest())
w.register(PackagesManifest())
with signal_error_raise():
w.get_plugin('ecpy.app.packages').collect_and_register()
# Edit the name of the package
assert w.get_plugin('ecpy_ext_demo')
def setup(self):
self.workbench = Workbench()
self.workbench.register(CoreManifest())
self.workbench.register(AppManifest())
self.workbench.register(PreferencesManifest())
self.workbench.register(StateManifest())
self.workbench.register(LogManifest())
def setup(self):
self.workbench = Workbench()
self.workbench.register(CoreManifest())
self.workbench.register(DependenciesManifest())
self.workbench.register(BuildDep())
self.workbench.register(RuntimeDep())
def setup(self):
self.workbench = Workbench()
self.workbench.register(CoreManifest())
self.workbench.register(StateManifest())
self.workbench.register(PreferencesManifest())
self.workbench.register(DependenciesManifest())
def setup(self):
self.workbench = Workbench()
self.workbench.register(CoreManifest())
self.workbench.register(StateManifest())
self.workbench.register(PreferencesManifest())
self.workbench.register(DependenciesManifest())
self.workbench.register(TaskManagerManifest())
self.workbench.register(MeasureManifest())
self.workbench.register(TestSuiteManifest())
def setup(self):
self.workbench = Workbench()
self.workbench.register(CoreManifest())
self.workbench.register(StateManifest())
self.workbench.register(PreferencesManifest())
self.workbench.register(TaskManagerManifest())
self.root = RootTask(should_stop=Event(), should_pause=Event())
self.task = LoadArrayTask(task_name='Test')
self.root.children_task.append(self.task)
def setup(self):
self.workbench = Workbench()
self.workbench.register(CoreManifest())
self.workbench.register(StateManifest())
self.workbench.register(PreferencesManifest())
self.workbench.register(DependenciesManifest())
self.workbench.register(PulsesManagerManifest())
self.plugin = self.workbench.get_plugin('hqc_meas.pulses')
def setup(self):
self.workbench = Workbench()
self.workbench.register(CoreManifest())
self.workbench.register(UIManifest())
self.workbench.register(StateManifest())
self.workbench.register(PreferencesManifest())
self.workbench.register(LogManifest())
self.workbench.register(MeasureManifest())
# Needed otherwise the monitor manifest is not registered.
self.workbench.get_plugin(u'hqc_meas.measure')
def workbench():
workbench = Workbench()
workbench.register(CoreManifest())
workbench.register(ContextManifest())
workbench.register(TestManifest())
context = workbench.get_plugin('psi.context')
print context.selectors['default'].order
print context.selectors['default'].parameters
print context.context_items['repetitions'].rove
for r in (20, 15, 10, 2):
context.selectors['default'].add_setting(dict(repetitions=r))
return workbench
def setup(self):
self.workbench = Workbench()
self.workbench.register(CoreManifest())
self.workbench.register(StateManifest())
self.workbench.register(PreferencesManifest())
self.workbench.register(InstrManagerManifest())
self.workbench.register(TaskManagerManifest())
self.root = RootTask(should_stop=Event(), should_pause=Event())
self.task = ApplyMagFieldTask(task_name='Test')
self.root.children_task.append(self.task)
self.root.run_time['drivers'] = {'Test': InstrHelper}
def setup(self):
self.workbench = Workbench()
self.workbench.register(CoreManifest())
self.workbench.register(UIManifest())
self.workbench.register(HqcAppManifest())
self.workbench.register(StateManifest())
self.workbench.register(PreferencesManifest())
self.workbench.register(LogManifest())
self.workbench.register(TaskManagerManifest())
self.workbench.register(InstrManagerManifest())
self.workbench.register(DebuggerManifest())
self.workbench.register(TestSuiteManifest())
def setup(self):
self.workbench = Workbench()
self.workbench.register(CoreManifest())
self.workbench.register(UIManifest())
self.workbench.register(HqcAppManifest())
self.workbench.register(StateManifest())
self.workbench.register(PreferencesManifest())
self.workbench.register(LogManifest())
self.workbench.register(DependenciesManifest())
self.workbench.register(TaskManagerManifest())
self.workbench.register(InstrManagerManifest())
self.workbench.register(MeasureManifest())
self.workbench.register(TestSuiteManifest())
# Adding by hand the false instr task.
plugin = self.workbench.get_plugin('hqc_meas.task_manager')
plugin._py_tasks['False instr'] = FalseInstrTask
def setup(self):
self.workbench = Workbench()
self.workbench.register(CoreManifest())
self.workbench.register(StateManifest())
self.workbench.register(PreferencesManifest())
self.workbench.register(InstrManagerManifest())
self.workbench.register(PulsesManagerManifest())
self.workbench.register(TaskManagerManifest())
self.root = RootTask(should_stop=Event(), should_pause=Event())
self.task = TransferPulseSequenceTask(task_name='Test')
self.root.children_task.append(self.task)
self.root.run_time['drivers'] = {'Test': InstrHelper}
self.sequence = RootSequence()
self.context = AWGContext()
self.sequence.context = self.context
self.sequence.external_vars = {'a': None}
pulse1 = Pulse(def_1='1.0', def_2='{a}', channel='Ch1_M1')
pulse2 = Pulse(def_1='{a} + 1.0', def_2='4.0', channel='Ch1_M1')
pulse3 = Pulse(def_1='{2_stop} + 0.5', def_2='10', channel='Ch1_M1')
self.sequence.items.extend([pulse1, pulse2, pulse3])
def dep_workbench():
"""Setup the workbench to test dependencies related capabilities.
"""
workbench = Workbench()
workbench.register(CoreManifest())
workbench.register(DependenciesManifest())
workbench.register(BuildDep())
workbench.register(RuntimeDep())
yield workbench
workbench.unregister('ecpy.app.dependencies')
workbench.unregister('enaml.workbench.core')
class TestLogPlugin(object):
"""Test all the commands deined by the LogPLugin.
"""
def setup(self):
self.workbench = Workbench()
self.workbench.register(CoreManifest())
self.workbench.register(AppManifest())
self.workbench.register(PreferencesManifest())
self.workbench.register(StateManifest())
self.workbench.register(LogManifest())
def teardown(self):
self.workbench.unregister(PLUGIN_ID)
def test_handler1(self, logger):
"""Test adding removing handler.
"""
core = self.workbench.get_plugin(u'enaml.workbench.core')
handler = GuiHandler(model=LogModel())
core.invoke_command('ecpy.app.logging.add_handler',
{'id': 'ui', 'handler': handler, 'logger': 'test'},
self)
log_plugin = self.workbench.get_plugin(PLUGIN_ID)
assert log_plugin.handler_ids == ['ui']
assert handler in logger.handlers
assert log_plugin._handlers == {'ui': (handler, 'test')}
core.invoke_command('ecpy.app.logging.remove_handler',
{'id': 'ui'}, self)
assert log_plugin.handler_ids == []
assert handler not in logger.handlers
assert log_plugin._handlers == {}
def test_handler2(self, logger):
"""Test adding a GUI handler using the mode keyword.
"""
core = self.workbench.get_plugin(u'enaml.workbench.core')
core.invoke_command('ecpy.app.logging.add_handler',
{'id': 'ui', 'mode': 'ui', 'logger': 'test'},
self)
log_plugin = self.workbench.get_plugin(PLUGIN_ID)
assert log_plugin.handler_ids == [u'ui']
assert logger.handlers
core.invoke_command('ecpy.app.logging.remove_handler',
{'id': 'ui'}, self)
assert log_plugin.handler_ids == []
assert not logger.handlers
def test_handler3(self, logger):
"""Test adding an handler using a non recognised mode.
"""
core = self.workbench.get_plugin(u'enaml.workbench.core')
core.invoke_command('ecpy.app.logging.add_handler',
{'id': 'ui', 'logger': 'test'},
self)
log_plugin = self.workbench.get_plugin(PLUGIN_ID)
assert log_plugin.handler_ids == []
assert not logger.handlers
def test_filter1(self, logger):
"""Test adding removing filter.
"""
core = self.workbench.get_plugin(u'enaml.workbench.core')
handler = GuiHandler(model=LogModel())
core.invoke_command('ecpy.app.logging.add_handler',
{'id': 'ui', 'handler': handler, 'logger': 'test'},
self)
class Filter(object):
def filter(self, record):
return True
test_filter = Filter()
core.invoke_command('ecpy.app.logging.add_filter',
{'id': 'filter', 'filter': test_filter,
'handler_id': 'ui'},
self)
log_plugin = self.workbench.get_plugin(PLUGIN_ID)
assert log_plugin.filter_ids == [u'filter']
assert log_plugin._filters == {u'filter': (test_filter, u'ui')}
core.invoke_command('ecpy.app.logging.remove_filter',
{'id': 'filter'}, self)
assert log_plugin.filter_ids == []
assert log_plugin._filters == {}
def test_filter2(self):
"""Test adding a filter and removing the handler.
"""
core = self.workbench.get_plugin(u'enaml.workbench.core')
handler = GuiHandler(model=LogModel())
core.invoke_command('ecpy.app.logging.add_handler',
{'id': 'ui', 'handler': handler, 'logger': 'test'},
self)
class Filter(object):
def filter(self, record):
return True
test_filter = Filter()
core.invoke_command('ecpy.app.logging.add_filter',
{'id': 'filter', 'filter': test_filter,
'handler_id': 'ui'},
self)
log_plugin = self.workbench.get_plugin(PLUGIN_ID)
assert log_plugin.filter_ids == [u'filter']
assert log_plugin._filters == {u'filter': (test_filter, u'ui')}
core.invoke_command('ecpy.app.logging.remove_handler',
{'id': 'ui'}, self)
assert log_plugin.filter_ids == []
assert log_plugin._filters == {}
def test_filter3(self, logger):
"""Test adding an improper filter.
"""
core = self.workbench.get_plugin(u'enaml.workbench.core')
core.invoke_command('ecpy.app.logging.add_filter',
{'id': 'filter', 'filter': object(),
'handler_id': 'ui'},
self)
def test_filter4(self, logger):
"""Test adding a filter to a non-existing handler.
"""
core = self.workbench.get_plugin(u'enaml.workbench.core')
class Filter(object):
def filter(self, record):
return True
core.invoke_command('ecpy.app.logging.add_filter',
{'id': 'filter', 'filter': Filter(),
'handler_id': 'ui'},
self)
def test_formatter(self, logger, app):
"""Test setting the formatter of a handler.
"""
core = self.workbench.get_plugin(u'enaml.workbench.core')
model = LogModel()
handler = GuiHandler(model=model)
core.invoke_command('ecpy.app.logging.add_handler',
{'id': 'ui', 'handler': handler, 'logger': 'test'},
self)
formatter = logging.Formatter('test : %(message)s')
core.invoke_command('ecpy.app.logging.set_formatter',
{'formatter': formatter, 'handler_id': 'ui'},
self)
logger.info('test')
process_app_events()
assert model.text == 'test : test\n'
def test_formatter2(self, logger, app):
"""Test setting the formatter of a non existing handler.
"""
core = self.workbench.get_plugin(u'enaml.workbench.core')
formatter = logging.Formatter('test : %(message)s')
core.invoke_command('ecpy.app.logging.set_formatter',
{'formatter': formatter,
'handler_id': 'non-existing'},
self)
process_app_events()
def test_start_logging1(self, app_dir):
"""Test startup function when redirection of sys.stdout is required
"""
cmd_args = CMDArgs()
cmd_args.nocapture = False
old = sys.stdout
app = self.workbench.get_plugin('ecpy.app')
app.run_app_startup(cmd_args)
plugin = self.workbench.get_plugin(PLUGIN_ID)
try:
assert os.path.isdir(os.path.join(app_dir, 'logs'))
assert 'ecpy.file_log' in plugin.handler_ids
assert 'ecpy.gui_log' in plugin.handler_ids
assert plugin.gui_model
assert isinstance(sys.stdout, StreamToLogRedirector)
assert isinstance(sys.stderr, StreamToLogRedirector)
finally:
sys.stdout = old
def test_start_logging2(self, app_dir):
"""Test startup function when redirection of sys.stdout is not required
"""
cmd_args = CMDArgs()
cmd_args.nocapture = True
old = sys.stdout
app = self.workbench.get_plugin('ecpy.app')
app.run_app_startup(cmd_args)
plugin = self.workbench.get_plugin(PLUGIN_ID)
try:
assert os.path.isdir(os.path.join(app_dir, 'logs'))
assert 'ecpy.file_log' in plugin.handler_ids
assert 'ecpy.gui_log' in plugin.handler_ids
assert plugin.gui_model
# Fail in no capture mode (unknown reason).
assert not isinstance(sys.stdout, StreamToLogRedirector)
assert not isinstance(sys.stderr, StreamToLogRedirector)
finally:
sys.stdout = old
class TestPluginCoreFunctionalities(object):
test_dir = ''
@classmethod
def setup_class(cls):
print complete_line(
__name__ + ':{}.setup_class()'.format(cls.__name__), '-', 77)
# Creating dummy directory for prefs (avoid prefs interferences).
directory = os.path.dirname(__file__)
cls.test_dir = os.path.join(directory, '_temps')
create_test_dir(cls.test_dir)
# Creating dummy default.ini file in utils.
util_path = os.path.join(directory, '..', '..', 'hqc_meas', 'utils',
'preferences')
def_path = os.path.join(util_path, 'default.ini')
# Making the preference manager look for info in test dir.
default = ConfigObj(def_path)
default['folder'] = cls.test_dir
default['file'] = 'default_test.ini'
default.write()
conf = ConfigObj(os.path.join(cls.test_dir, 'default_test.ini'))
conf[u'hqc_meas.measure'] = {}
conf.write()
@classmethod
def teardown_class(cls):
print complete_line(
__name__ + ':{}.teardown_class()'.format(cls.__name__), '-', 77)
# Removing pref files creating during tests.
remove_tree(cls.test_dir)
# Restoring default.ini file in utils
directory = os.path.dirname(__file__)
util_path = os.path.join(directory, '..', '..', 'hqc_meas', 'utils',
'preferences')
def_path = os.path.join(util_path, 'default.ini')
os.remove(def_path)
def setup(self):
self.workbench = Workbench()
self.workbench.register(CoreManifest())
self.workbench.register(StateManifest())
self.workbench.register(PreferencesManifest())
self.workbench.register(DependenciesManifest())
def teardown(self):
self.workbench.unregister(u'hqc_meas.measure')
self.workbench.unregister(u'hqc_meas.dependencies')
self.workbench.unregister(u'hqc_meas.preferences')
self.workbench.unregister(u'hqc_meas.state')
self.workbench.unregister(u'enaml.workbench.core')
def test_init(self):
""" Test automatic registration at init.
"""
# Tamper with prefs to alter startup.
pref_plugin = self.workbench.get_plugin(u'hqc_meas.preferences')
prefs = {
'manifests': repr([('tests.measurement.dummies', 'DummyCheck1')])
}
pref_plugin._prefs[u'hqc_meas.measure'].update(prefs)
self.workbench.register(MeasureManifest())
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
pref_plugin._prefs[u'hqc_meas.measure'] = {}
assert_in(u'dummy.check1', plugin._manifest_ids)
assert_in(u'dummy.check1', plugin.checks)
# Automatically registered plugins are automatically unregistered.
# --- Checks tests --------------------------------------------------------
def test_check_registation1(self):
""" Test that checks are properly found at start-up.
"""
self.workbench.register(MeasureManifest())
self.workbench.register(DummyCheck1())
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
assert_in(u'dummy.check1', plugin.checks)
self.workbench.unregister(u'dummy.check1')
assert_not_in(u'dummy.check1', plugin.checks)
assert_equal(plugin._check_extensions, {})
def test_check_registration2(self):
""" Test checks update when a new plugin is registered.
"""
self.workbench.register(MeasureManifest())
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
self.workbench.register(DummyCheck1())
assert_in(u'dummy.check1', plugin.checks)
self.workbench.unregister(u'dummy.check1')
assert_not_in(u'dummy.check1', plugin.checks)
def test_check_factory(self):
""" Test getting the Check decl from a factory.
"""
self.workbench.register(MeasureManifest())
self.workbench.register(DummyCheck3())
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
assert_in(u'dummy.check3', plugin.checks)
self.workbench.unregister(u'dummy.check3')
assert_not_in(u'dummy.check3', plugin.checks)
@raises(ValueError)
def test_check_errors1(self):
""" Test uniqueness of check id.
"""
self.workbench.register(MeasureManifest())
self.workbench.register(DummyCheck1())
self.workbench.register(DummyCheck1bis())
self.workbench.get_plugin(u'hqc_meas.measure')
@raises(ValueError)
def test_check_errors2(self):
""" Test presence of perfom_test in Check.
"""
self.workbench.register(MeasureManifest())
self.workbench.register(DummyCheck2())
self.workbench.get_plugin(u'hqc_meas.measure')
@raises(TypeError)
def test_check_errors3(self):
""" Test enforcement of type for Check when using factory.
"""
self.workbench.register(MeasureManifest())
self.workbench.register(DummyCheck4())
self.workbench.get_plugin(u'hqc_meas.measure')
# --- Headers tests -------------------------------------------------------
def test_header_registation1(self):
""" Test that headers are properly found at start-up.
"""
self.workbench.register(MeasureManifest())
self.workbench.register(DummyHeader1())
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
assert_in(u'dummy.header1', plugin.headers)
self.workbench.unregister(u'dummy.header1')
assert_not_in(u'dummy.header1', plugin.headers)
assert_equal(plugin._header_extensions, {})
def test_header_registration2(self):
""" Test headers update when a new plugin is registered.
"""
self.workbench.register(MeasureManifest())
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
self.workbench.register(DummyHeader1())
assert_in(u'dummy.header1', plugin.headers)
self.workbench.unregister(u'dummy.header1')
assert_not_in(u'dummy.header1', plugin.headers)
def test_header_factory(self):
""" Test getting the Header decl from a factory.
"""
self.workbench.register(MeasureManifest())
self.workbench.register(DummyHeader3())
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
assert_in(u'dummy.header3', plugin.headers)
self.workbench.unregister(u'dummy.header3')
assert_not_in(u'dummy.header3', plugin.headers)
@raises(ValueError)
def test_header_errors1(self):
""" Test uniqueness of header id.
"""
self.workbench.register(MeasureManifest())
self.workbench.register(DummyHeader1())
self.workbench.register(DummyHeader1bis())
self.workbench.get_plugin(u'hqc_meas.measure')
@raises(ValueError)
def test_header_errors2(self):
""" Test presence of build_header in Header.
"""
self.workbench.register(MeasureManifest())
self.workbench.register(DummyHeader2())
self.workbench.get_plugin(u'hqc_meas.measure')
@raises(TypeError)
def test_header_errors3(self):
""" Test enforcement of type for Header when using factory.
"""
self.workbench.register(MeasureManifest())
self.workbench.register(DummyHeader4())
self.workbench.get_plugin(u'hqc_meas.measure')
# --- Editors tests -------------------------------------------------------
def test_editor_registation1(self):
""" Test that editors are properly found at start-up.
"""
self.workbench.register(MeasureManifest())
self.workbench.register(DummyEditor1())
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
assert_in(u'dummy.editor1', plugin.editors)
self.workbench.unregister(u'dummy.editor1')
assert_not_in(u'dummy.editor1', plugin.editors)
assert_equal(plugin._editor_extensions, {})
def test_editor_registration2(self):
""" Test editors update when a new plugin is registered.
"""
self.workbench.register(MeasureManifest())
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
self.workbench.register(DummyEditor1())
assert_in(u'dummy.editor1', plugin.editors)
self.workbench.unregister(u'dummy.editor1')
assert_not_in(u'dummy.editor1', plugin.editors)
def test_editor_factory(self):
""" Test getting the Editor decl from a factory.
"""
self.workbench.register(MeasureManifest())
self.workbench.register(DummyEditor3())
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
assert_in(u'dummy.editor3', plugin.editors)
self.workbench.unregister(u'dummy.editor3')
assert_not_in(u'dummy.editor3', plugin.editors)
@raises(ValueError)
def test_editor_errors1(self):
""" Test uniqueness of editor id.
"""
self.workbench.register(MeasureManifest())
self.workbench.register(DummyEditor1())
self.workbench.register(DummyEditor1bis())
self.workbench.get_plugin(u'hqc_meas.measure')
@raises(ValueError)
def test_editor_errors2(self):
""" Test presence of factory in Editor.
"""
self.workbench.register(MeasureManifest())
self.workbench.register(DummyEditor2())
self.workbench.get_plugin(u'hqc_meas.measure')
@raises(TypeError)
def test_editor_errors3(self):
""" Test enforcement of type for Editor when using factory.
"""
self.workbench.register(MeasureManifest())
self.workbench.register(DummyEditor4())
self.workbench.get_plugin(u'hqc_meas.measure')
# --- Monitors tests ------------------------------------------------------
def test_monitor_registation1(self):
""" Test that monitors are properly found at start-up.
"""
self.workbench.register(MeasureManifest())
self.workbench.register(DummyMonitor1())
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
assert_in(u'dummy.monitor1', plugin.monitors)
self.workbench.unregister(u'dummy.monitor1')
assert_not_in(u'dummy.monitor1', plugin.monitors)
assert_equal(plugin._monitor_extensions, {})
def test_monitor_registration2(self):
""" Test monitors update when a new plugin is registered.
"""
self.workbench.register(MeasureManifest())
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
self.workbench.register(DummyMonitor1())
assert_in(u'dummy.monitor1', plugin.monitors)
self.workbench.unregister(u'dummy.monitor1')
assert_not_in(u'dummy.monitor1', plugin.monitors)
def test_monitor_factory(self):
""" Test getting the Monitor decl from a factory.
"""
self.workbench.register(MeasureManifest())
self.workbench.register(DummyMonitor3())
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
assert_in(u'dummy.monitor3', plugin.monitors)
self.workbench.unregister(u'dummy.monitor3')
assert_not_in(u'dummy.monitor3', plugin.monitors)
@raises(ValueError)
def test_monitor_errors1(self):
""" Test uniqueness of monitor id.
"""
self.workbench.register(MeasureManifest())
self.workbench.register(DummyMonitor1())
self.workbench.register(DummyMonitor1bis())
self.workbench.get_plugin(u'hqc_meas.measure')
@raises(ValueError)
def test_monitor_errors2(self):
""" Test presence of factory in Monitor.
"""
self.workbench.register(MeasureManifest())
self.workbench.register(DummyMonitor2())
self.workbench.get_plugin(u'hqc_meas.measure')
@raises(TypeError)
def test_monitor_errors3(self):
""" Test enforcement of type for Monitor when using factory.
"""
self.workbench.register(MeasureManifest())
self.workbench.register(DummyMonitor4())
self.workbench.get_plugin(u'hqc_meas.measure')
# --- Engines tests -------------------------------------------------------
def test_engine_registation1(self):
""" Test that engines are properly found at start-up.
"""
self.workbench.register(MeasureManifest())
self.workbench.register(DummyEngine1())
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
assert_in(u'dummy.engine1', plugin.engines)
self.workbench.unregister(u'dummy.engine1')
assert_not_in(u'dummy.engine1', plugin.engines)
assert_equal(plugin._engine_extensions, {})
def test_engine_registration2(self):
""" Test engines update when a new plugin is registered.
"""
self.workbench.register(MeasureManifest())
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
self.workbench.register(DummyEngine1())
assert_in(u'dummy.engine1', plugin.engines)
self.workbench.unregister(u'dummy.engine1')
assert_not_in(u'dummy.engine1', plugin.engines)
def test_engine_factory(self):
""" Test getting the Engine decl from a factory.
"""
self.workbench.register(MeasureManifest())
self.workbench.register(DummyEngine3())
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
assert_in(u'dummy.engine3', plugin.engines)
self.workbench.unregister(u'dummy.engine3')
assert_not_in(u'dummy.engine3', plugin.engines)
@raises(ValueError)
def test_engine_errors1(self):
""" Test uniqueness of engine id.
"""
self.workbench.register(MeasureManifest())
self.workbench.register(DummyEngine1())
self.workbench.register(DummyEngine1bis())
self.workbench.get_plugin(u'hqc_meas.measure')
@raises(ValueError)
def test_engine_errors2(self):
""" Test presence of factory in Engine.
"""
self.workbench.register(MeasureManifest())
self.workbench.register(DummyEngine2())
self.workbench.get_plugin(u'hqc_meas.measure')
@raises(TypeError)
def test_engine_errors3(self):
""" Test enforcement of type for Engine when using factory.
"""
self.workbench.register(MeasureManifest())
self.workbench.register(DummyEngine4())
self.workbench.get_plugin(u'hqc_meas.measure')
def test_selected_engine1(self):
""" Test selected engine from preferences is kept if found.
"""
# Tamper with prefs to alter startup.
pref_plugin = self.workbench.get_plugin(u'hqc_meas.preferences')
prefs = {'selected_engine': u'dummy.engine1'}
pref_plugin._prefs[u'hqc_meas.measure'].update(prefs)
self.workbench.register(MeasureManifest())
self.workbench.register(DummyEngine1())
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
pref_plugin._prefs[u'hqc_meas.measure'] = {}
assert_equal(plugin.selected_engine, u'dummy.engine1')
assert plugin.engines[u'dummy.engine1'].post_selected
self.workbench.unregister(u'dummy.engine1')
def test_selected_engine2(self):
""" Test selected engine from preferences is deleted if not found.
"""
# Tamper with prefs to alter startup.
pref_plugin = self.workbench.get_plugin(u'hqc_meas.preferences')
prefs = {'selected_engine': u'dummy.engine1'}
pref_plugin._prefs[u'hqc_meas.measure'].update(prefs)
self.workbench.register(MeasureManifest())
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
pref_plugin._prefs[u'hqc_meas.measure'] = {}
assert_equal(plugin.selected_engine, u'')
def test_selected_engine3(self):
""" Test observer is called when new engine selected.
"""
self.workbench.register(MeasureManifest())
self.workbench.register(DummyEngine1())
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
plugin.selected_engine = u'dummy.engine1'
assert plugin.engines[u'dummy.engine1'].post_selected
plugin.selected_engine = u''
assert plugin.engines[u'dummy.engine1'].post_deselected
class TestDeclaratorCollector(object):
"""Test the ExtensionsCollector behaviour.
"""
def setup(self):
self.workbench = Workbench()
self.workbench.register(CoreManifest())
self.workbench.register(ErrorsManifest())
self.workbench.register(DeclaratorManifest())
def test_registation1(self, windows):
"""Test that plugin registered before starting the plugin are well
detected
"""
d = DContributor1()
self.workbench.register(d)
plugin = self.workbench.get_plugin(PLUGIN_ID)
assert 'contrib1' in plugin.contribs.contributions
self.workbench.unregister(d.id)
assert not plugin.contribs.contributions
assert not plugin.contribs._extensions
def test_registration2(self, windows):
"""Test contribs update when a new plugin is registered.
"""
self.workbench.register(DContributor2())
plugin = self.workbench.get_plugin(PLUGIN_ID)
d = DContributor1()
self.workbench.register(d)
assert 'contrib1' in plugin.contribs.contributions
self.workbench.unregister(d.id)
assert 'contrib1' not in plugin.contribs.contributions
plugin.contribs.stop()
assert not plugin.contribs.contributions
assert not plugin.contribs._extensions
def test_factory(self, windows):
"""Test getting the TestDeclarator declaration from a factory.
"""
d = DContributor2()
self.workbench.register(d)
plugin = self.workbench.get_plugin(PLUGIN_ID)
assert 'contrib2' in plugin.contribs.contributions
self.workbench.unregister(d.id)
assert not plugin.contribs.contributions
def test_check_errors1(self, windows):
"""Test enforcement of type when using factory.
"""
self.workbench.register(DContributor3())
with handle_dialog():
self.workbench.get_plugin(PLUGIN_ID)
@pytest.mark.ui
def test_declarator_failed_registration(self, windows):
"""Test handling of error when a declarator fail to register.
"""
self.workbench.register(DContributor4())
with handle_dialog():
self.workbench.get_plugin(PLUGIN_ID)
@pytest.mark.ui
def test_unsatifiable_requirement(self):
"""Test the case of a declarator always adding itself to _deflayed.
"""
self.workbench.register(DContributor5())
with handle_dialog():
self.workbench.get_plugin(PLUGIN_ID)
def setup(self):
self.workbench = Workbench()
self.workbench.register(CoreManifest())
self.workbench.register(StateManifest())
self.workbench.register(PreferencesManifest())
def setup(self):
self.workbench = Workbench()
self.workbench.register(CoreManifest())
self.workbench.register(DependenciesManifest())
class TestCollectingFromObject(object):
"""Test collecting dependencies of live objects.
"""
def setup(self):
self.workbench = Workbench()
self.workbench.register(CoreManifest())
self.workbench.register(DependenciesManifest())
self.workbench.register(BuildDep())
self.workbench.register(RuntimeDep())
def teardown(self):
self.workbench.unregister('ecpy.app.dependencies')
self.workbench.unregister('enaml.workbench.core')
def test_collecting_build(self, dependent_object):
"""Test collecting only the build dependencies.
"""
core = self.workbench.get_plugin('enaml.workbench.core')
res, dep = core.invoke_command(COLLECT, {'obj': dependent_object})
assert res
assert dep.keys() == ['test']
def test_collecting_runtime(self, dependent_object):
"""Test collecting only the runtime dependencies.
"""
plugin = self.workbench.get_plugin('ecpy.app.dependencies')
core = self.workbench.get_plugin('enaml.workbench.core')
res, dep = core.invoke_command(COLLECT, {'obj': dependent_object,
'dependencies': ['runtime']},
plugin)
assert res
assert dep.keys() == ['test_run']
def test_collecting_all(self, dependent_object):
"""Test collecting all dependencies.
"""
core = self.workbench.get_plugin('enaml.workbench.core')
res, dep = core.invoke_command(COLLECT, {'obj': dependent_object,
'dependencies': ['build',
'runtime'],
'owner': 'ecpy.test'})
assert res
assert dep[0].keys() == ['test']
assert dep[1].keys() == ['test_run']
def test_handling_errors(self, monkeypatch, dependent_object):
"""Test handling errors occuring when collecting dependencies.
"""
plugin = self.workbench.get_plugin('ecpy.app.dependencies')
for b in plugin.build_deps.contributions.values():
monkeypatch.setattr(b, 'err', True)
for r in plugin.run_deps.contributions.values():
monkeypatch.setattr(r, 'err', True)
core = self.workbench.get_plugin('enaml.workbench.core')
res, dep = core.invoke_command(COLLECT, {'obj': dependent_object,
'dependencies': ['build',
'runtime'],
'owner': 'ecpy.test'})
assert not res
assert 'test' in dep[0] and 'test_run' in dep[1]
def test_handling_missing_caller(self, dependent_object):
"""Test handling a missing caller when runtime dependencies are
requested.
"""
core = self.workbench.get_plugin('enaml.workbench.core')
res, dep = core.invoke_command(COLLECT, {'obj': dependent_object,
'dependencies': ['runtime']})
assert not res
assert 'owner' in dep
def test_handling_unknown_dep_type(self, dependent_object):
"""Test handling an unknown dep_type.
"""
dependent_object.dep_type = 'Unknown'
core = self.workbench.get_plugin('enaml.workbench.core')
res, dep = core.invoke_command(COLLECT, {'obj': dependent_object})
assert not res
assert 'Unknown' in dep
def test_handling_missing_runtime_collector(self, monkeypatch,
dependent_object):
"""Test handling an unknown dep_type.
"""
plugin = self.workbench.get_plugin('ecpy.app.dependencies')
for b in plugin.build_deps.contributions.values():
monkeypatch.setattr(b, 'run', ('unkwown',))
core = self.workbench.get_plugin('enaml.workbench.core')
res, dep = core.invoke_command(COLLECT, {'obj': dependent_object,
'dependencies': ['runtime'],
'owner': object()})
assert not res
assert 'runtime' in dep
class TestMeasureSpace(object):
test_dir = ''
@classmethod
def setup_class(cls):
print complete_line(
__name__ + ':{}.setup_class()'.format(cls.__name__), '-', 77)
# Creating dummy directory for prefs (avoid prefs interferences).
directory = os.path.dirname(__file__)
cls.test_dir = os.path.join(directory, '_temps')
create_test_dir(cls.test_dir)
# Creating dummy default.ini file in utils.
util_path = os.path.join(directory, '..', '..', 'hqc_meas', 'utils',
'preferences')
def_path = os.path.join(util_path, 'default.ini')
# Making the preference manager look for info in test dir.
default = ConfigObj(def_path)
default['folder'] = cls.test_dir
default['file'] = 'default_test.ini'
default.write()
# Creating dummy profile.
profile_path = os.path.join(directory, '..', '..', 'hqc_meas',
'instruments', 'profiles')
if not os.path.isdir(profile_path):
os.mkdir(profile_path)
conf = ConfigObj(os.path.join(profile_path, '__dummy__.ini'))
conf.write()
conf = ConfigObj(os.path.join(cls.test_dir, 'default_test.ini'))
conf[u'hqc_meas.measure'] = {}
conf.write()
@classmethod
def teardown_class(cls):
print complete_line(
__name__ + ':{}.teardown_class()'.format(cls.__name__), '-', 77)
# Removing pref files creating during tests.
remove_tree(cls.test_dir)
directory = os.path.dirname(__file__)
# Removing false profile.
profile_path = os.path.join(directory, '..', '..', 'hqc_meas',
'instruments', 'profiles')
os.remove(os.path.join(profile_path, '__dummy__.ini'))
# Restoring default.ini file in utils
directory = os.path.dirname(__file__)
util_path = os.path.join(directory, '..', '..', 'hqc_meas', 'utils',
'preferences')
def_path = os.path.join(util_path, 'default.ini')
os.remove(def_path)
def setup(self):
self.workbench = Workbench()
self.workbench.register(CoreManifest())
self.workbench.register(UIManifest())
self.workbench.register(HqcAppManifest())
self.workbench.register(StateManifest())
self.workbench.register(PreferencesManifest())
self.workbench.register(LogManifest())
self.workbench.register(DependenciesManifest())
self.workbench.register(TaskManagerManifest())
self.workbench.register(InstrManagerManifest())
self.workbench.register(MeasureManifest())
self.workbench.register(TestSuiteManifest())
# Adding by hand the false instr task.
plugin = self.workbench.get_plugin('hqc_meas.task_manager')
plugin._py_tasks['False instr'] = FalseInstrTask
def teardown(self):
close_all_windows()
core = self.workbench.get_plugin(u'enaml.workbench.core')
core.invoke_command(u'enaml.workbench.ui.close_workspace', {}, self)
self.workbench.unregister(u'tests.suite')
self.workbench.unregister(u'hqc_meas.measure')
self.workbench.unregister(u'hqc_meas.task_manager')
self.workbench.unregister(u'hqc_meas.instr_manager')
self.workbench.unregister(u'hqc_meas.dependencies')
self.workbench.unregister(u'hqc_meas.logging')
self.workbench.unregister(u'hqc_meas.preferences')
self.workbench.unregister(u'hqc_meas.state')
self.workbench.unregister(u'hqc_meas.app')
self.workbench.unregister(u'enaml.workbench.ui')
self.workbench.unregister(u'enaml.workbench.core')
def test_life_cycle(self):
""" Test that workspace starting/closing goes well
"""
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
plugin.selected_engine = u'engine1'
core = self.workbench.get_plugin(u'enaml.workbench.core')
cmd = u'enaml.workbench.ui.select_workspace'
core.invoke_command(cmd, {'workspace': u'hqc_meas.measure.workspace'},
self)
log_plugin = self.workbench.get_plugin(u'hqc_meas.logging')
# Check the plugin got the workspace
assert_true(plugin.workspace)
workspace = plugin.workspace
# Check the workspace registration.
assert_true(workspace.log_model)
assert_in(LOG_ID, log_plugin.handler_ids)
logger = logging.getLogger(__name__)
logger.info('test')
process_app_events()
assert_in('test', workspace.log_model.text)
# Check a blank measure was created.
assert_true(plugin.edited_measure)
assert_true(plugin.edited_measure.plugin)
# Check the engine engine is contributing.
assert_true(plugin.engines[u'engine1'].contributing)
# Check the workspace is observing the selected_engine
observer = workspace._update_engine_contribution
assert_true(plugin.has_observer('selected_engine', observer))
cmd = u'enaml.workbench.ui.close_workspace'
core.invoke_command(cmd, {}, self)
# Check the workspace is not observing anymore the selected_engine
assert_false(plugin.has_observer('selected_engine', observer))
# Check the workspace removed its log handler.
assert_not_in(LOG_ID, log_plugin.handler_ids)
# Check the reference to the workspace was destroyed.
assert_equal(plugin.workspace, None)
# Check the engine contribution was removed.
assert_false(plugin.engines[u'engine1'].contributing)
def test_engine_contribution_observer1(self):
""" Test engine selected before workspace starts does contribute.
"""
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
plugin.selected_engine = u'engine1'
core = self.workbench.get_plugin(u'enaml.workbench.core')
cmd = u'enaml.workbench.ui.select_workspace'
core.invoke_command(cmd, {'workspace': u'hqc_meas.measure.workspace'},
self)
process_app_events()
assert_true(plugin.engines[u'engine1'].contributing)
plugin.selected_engine = u''
assert_false(plugin.engines[u'engine1'].contributing)
def test_engine_contribution_observer2(self):
""" Test engine selected after workspace starts does contribute.
"""
core = self.workbench.get_plugin(u'enaml.workbench.core')
cmd = u'enaml.workbench.ui.select_workspace'
core.invoke_command(cmd, {'workspace': u'hqc_meas.measure.workspace'},
self)
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
plugin.selected_engine = u'engine1'
assert_true(plugin.engines[u'engine1'].contributing)
plugin.selected_engine = u''
assert_false(plugin.engines[u'engine1'].contributing)
def test_enqueue_measure1(self):
# Test enqueueing a measure passing the tests using no instruments.
core = self.workbench.get_plugin(u'enaml.workbench.core')
cmd = u'enaml.workbench.ui.select_workspace'
core.invoke_command(cmd, {'workspace': u'hqc_meas.measure.workspace'},
self)
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
measure = Measure(plugin=plugin, name='Test')
measure.root_task = RootTask(default_path=self.test_dir)
plugin.edited_measure = measure
res = plugin.workspace.enqueue_measure(plugin.edited_measure)
assert_true(res)
assert_false(measure.root_task.run_time)
assert_true(plugin.enqueued_measures)
en_meas = plugin.enqueued_measures[0]
assert_is_not(en_meas, measure)
assert_equal(en_meas.status, 'READY')
assert_equal(en_meas.infos,
'The measure is ready to be performed by an engine.')
assert_in('build_deps', en_meas.store)
assert_not_in('profiles', en_meas.store)
def test_enqueue_measure2(self):
# Test enqueueing a measure failing the tests using no instruments.
core = self.workbench.get_plugin(u'enaml.workbench.core')
cmd = u'enaml.workbench.ui.select_workspace'
core.invoke_command(cmd, {'workspace': u'hqc_meas.measure.workspace'},
self)
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
measure = Measure(plugin=plugin, name='Test')
measure.root_task = RootTask()
plugin.edited_measure = measure
res = plugin.workspace.enqueue_measure(plugin.edited_measure)
assert_false(res)
assert_false(measure.root_task.run_time)
assert_false(plugin.enqueued_measures)
close_all_windows()
def test_enqueue_measure3(self):
# Test enqueueing a measure passing the test but emitting warnings.
# As there is no event loop running the exec_ is not blocking.
core = self.workbench.get_plugin(u'enaml.workbench.core')
cmd = u'enaml.workbench.ui.select_workspace'
core.invoke_command(cmd, {'workspace': u'hqc_meas.measure.workspace'},
self)
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
measure = Measure(plugin=plugin, name='Test')
measure.root_task = RootTask()
plugin.edited_measure = measure
res = plugin.workspace.enqueue_measure(plugin.edited_measure)
assert_false(res)
assert_false(measure.root_task.run_time)
assert_false(plugin.enqueued_measures)
close_all_windows()
def test_enqueue_measure4(self):
# Test enqueueing a measure passing the tests using instruments.
core = self.workbench.get_plugin(u'enaml.workbench.core')
cmd = u'enaml.workbench.ui.select_workspace'
core.invoke_command(cmd, {'workspace': u'hqc_meas.measure.workspace'},
self)
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
false_instr_user = FalseInstrTask(selected_profile=' dummy ',
selected_driver='PanelTestDummy')
measure = Measure(plugin=plugin, name='Test')
measure.root_task = RootTask(default_path=self.test_dir)
measure.root_task.children_task = [false_instr_user]
plugin.edited_measure = measure
res = plugin.workspace.enqueue_measure(plugin.edited_measure)
assert_true(res)
assert_false(measure.root_task.run_time)
assert_true(plugin.enqueued_measures)
en_meas = plugin.enqueued_measures[0]
assert_is_not(en_meas, measure)
assert_equal(en_meas.status, 'READY')
assert_equal(en_meas.infos,
'The measure is ready to be performed by an engine.')
assert_in('build_deps', en_meas.store)
assert_equal([' dummy '], en_meas.store['profiles'])
assert_in('drivers', en_meas.root_task.run_time)
instr_plugin = self.workbench.get_plugin('hqc_meas.instr_manager')
assert_in(' dummy ', instr_plugin.available_profiles)
def test_enqueue_measure5(self):
# Test enqueueing a measure failing the tests using instruments.
core = self.workbench.get_plugin(u'enaml.workbench.core')
cmd = u'enaml.workbench.ui.select_workspace'
core.invoke_command(cmd, {'workspace': u'hqc_meas.measure.workspace'},
self)
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
measure = Measure(plugin=plugin, name='Test')
measure.root_task = RootTask()
plugin.edited_measure = measure
res = plugin.workspace.enqueue_measure(plugin.edited_measure)
assert_false(res)
assert_false(measure.root_task.run_time)
assert_false(plugin.enqueued_measures)
instr_plugin = self.workbench.get_plugin('hqc_meas.instr_manager')
assert_in(' dummy ', instr_plugin.available_profiles)
close_all_windows()
def test_reenqueue_measure(self):
# Test re-enqueueing a measure.
core = self.workbench.get_plugin(u'enaml.workbench.core')
cmd = u'enaml.workbench.ui.select_workspace'
core.invoke_command(cmd, {'workspace': u'hqc_meas.measure.workspace'},
self)
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
measure = self._create_measure(plugin)
measure.enter_running_state()
plugin.workspace.reenqueue_measure(measure)
assert_equal(measure.status, 'READY')
assert_equal(measure.infos, 'Measure re-enqueued by the user')
assert_true(measure.root_task.task_database.has_observers('notifier'))
def test_plugin_find_next_measure1(self):
""" Test plugin.find_next_measure, first measure is ok.
"""
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
measure = Measure(plugin=plugin, name='Test')
measure.root_task = RootTask()
plugin.enqueued_measures.append(measure)
meas = plugin.find_next_measure()
assert_is(measure, meas)
def test_plugin_find_next_measure2(self):
""" Test plugin.find_next_measure when measures should be skipped.
"""
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
measure1 = Measure(plugin=plugin, name='Test1')
measure1.root_task = RootTask()
measure1.status = 'SKIPPED'
plugin.enqueued_measures.append(measure1)
measure2 = Measure(plugin=plugin, name='Test2')
measure2.root_task = RootTask()
measure2.status = 'EDITING'
plugin.enqueued_measures.append(measure2)
measure3 = Measure(plugin=plugin, name='Test3')
measure3.root_task = RootTask()
measure3.status = 'READY'
plugin.enqueued_measures.append(measure3)
meas = plugin.find_next_measure()
assert_is(measure3, meas)
def test_plugin_find_next_measure3(self):
""" Test plugin.find_next_measure when no measures can be sent.
"""
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
measure1 = Measure(plugin=plugin, name='Test1')
measure1.root_task = RootTask()
measure1.status = 'SKIPPED'
plugin.enqueued_measures.append(measure1)
measure2 = Measure(plugin=plugin, name='Test2')
measure2.root_task = RootTask()
measure2.status = 'EDITING'
plugin.enqueued_measures.append(measure2)
meas = plugin.find_next_measure()
assert_is(None, meas)
def test_measure_processing1(self):
""" Test the processing of a single measure.
"""
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
measure1 = self._create_measure(plugin)
plugin.enqueued_measures.append(measure1)
core = self.workbench.get_plugin(u'enaml.workbench.core')
cmd = u'enaml.workbench.ui.select_workspace'
core.invoke_command(cmd, {'workspace': u'hqc_meas.measure.workspace'},
self)
workspace = plugin.workspace
plugin.selected_engine = u'engine1'
workspace.start_processing_measures()
# Check the right flag is set in the plugin.
assert_in('processing', plugin.flags)
# Check an engine instance was created and is processing the measure.
assert_true(plugin.engine_instance)
engine = plugin.engine_instance
assert_true(engine.ready)
assert_true(engine.running)
# Check the plugin observe the done event.
assert_true(engine.has_observer('done', plugin._listen_to_engine))
# Check the measure has been registered as running and its status been
# updated.
assert_true(plugin.running_measure)
measure = plugin.running_measure
assert_equal(measure.status, 'RUNNING')
assert_equal(measure.infos, 'The measure is running')
# Check the monitors connections, that it started and received notif.
monitor = measure.monitors.values()[0]
assert_true(engine.has_observer('news', monitor.process_news))
assert_equal(monitor.black_box, ['Started'])
assert_equal(monitor.engine_news, {'root/default_path': 'test'})
# Make the engine send the done event.
engine.complete_measure()
# Check engine state.
assert_false(engine.active)
assert_false(engine.has_observers('news'))
# Check measure state.
assert_equal(measure.status, 'COMPLETED')
assert_equal(measure.infos, 'Measure successfully completed')
# Check plugin state.
assert_false(plugin.flags)
# Closing workspace.
core = self.workbench.get_plugin(u'enaml.workbench.core')
core.invoke_command(u'enaml.workbench.ui.close_workspace', {}, self)
# Check monitors stopped properly.
assert_equal(monitor.black_box, ['Started', 'Stopped'])
def test_measure_processing2(self):
""" Test the processing of a two measures in a row.
"""
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
measure1 = self._create_measure(plugin)
plugin.enqueued_measures.append(measure1)
measure2 = self._create_measure(plugin)
plugin.enqueued_measures.append(measure2)
core = self.workbench.get_plugin(u'enaml.workbench.core')
cmd = u'enaml.workbench.ui.select_workspace'
core.invoke_command(cmd, {'workspace': u'hqc_meas.measure.workspace'},
self)
workspace = plugin.workspace
plugin.selected_engine = u'engine1'
workspace.start_processing_measures()
# Check the right flag is set in the plugin.
assert_in('processing', plugin.flags)
# Check an engine instance was created and is processing the measure.
assert_true(plugin.engine_instance)
engine = plugin.engine_instance
# Check the measure has been registered as running and its status been
# updated.
assert_true(plugin.running_measure)
measure = plugin.running_measure
assert_is(measure, measure1)
# Make the engine send the done event.
engine.complete_measure()
# Check measure1 state.
assert_equal(measure1.status, 'COMPLETED')
assert_equal(measure1.infos, 'Measure successfully completed')
# Check the measure has been registered as running and its status been
# updated.
assert_true(plugin.running_measure)
measure = plugin.running_measure
assert_is(measure, measure2)
# Make the engine send the done event.
engine.complete_measure()
# Check engine state.
assert_false(engine.active)
assert_false(engine.has_observers('news'))
# Check measure state.
assert_equal(measure2.status, 'COMPLETED')
assert_equal(measure2.infos, 'Measure successfully completed')
assert_false(plugin.flags)
def test_measure_processing3(self):
""" Test the processing of a measure failing the tests.
"""
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
measure1 = self._create_measure(plugin)
measure1.root_task.default_path = ''
plugin.enqueued_measures.append(measure1)
core = self.workbench.get_plugin(u'enaml.workbench.core')
cmd = u'enaml.workbench.ui.select_workspace'
core.invoke_command(cmd, {'workspace': u'hqc_meas.measure.workspace'},
self)
workspace = plugin.workspace
plugin.selected_engine = u'engine1'
workspace.start_processing_measures()
process_app_events()
# Check the right flag is set in the plugin.
assert_not_in('processing', plugin.flags)
# Check the measure status has been updated.
assert_true(plugin.running_measure)
measure = plugin.running_measure
assert_equal(measure.status, 'FAILED')
assert_equal(measure.infos, 'Failed to pass the built in tests')
assert_false(plugin.flags)
def test_measure_processing4(self):
""" Test the processing of a measure failing to get some profiles.
"""
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
measure1 = self._create_measure(plugin)
plugin.enqueued_measures.append(measure1)
measure1.store['profiles'] = ['Test']
# Here to avoid looking for build deps and concluing the measure does
# not actually need any profile.
measure1.store['build_deps'] = {}
core = self.workbench.get_plugin(u'enaml.workbench.core')
cmd = u'enaml.workbench.ui.select_workspace'
core.invoke_command(cmd, {'workspace': u'hqc_meas.measure.workspace'},
self)
workspace = plugin.workspace
plugin.selected_engine = u'engine1'
workspace.start_processing_measures()
process_app_events()
# Check the right flag is set in the plugin.
assert_not_in('processing', plugin.flags)
# Check the measure status has been updated.
assert_true(plugin.running_measure)
measure = plugin.running_measure
assert_equal(measure.status, 'SKIPPED')
assert_equal(measure.infos, 'Failed to get requested profiles')
assert_false(plugin.flags)
def test_measure_processing5(self):
# Test processing a measure using an instr, which has tested the
# connection to the instr and not been re-edited.
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
instr_plugin = self.workbench.get_plugin('hqc_meas.instr_manager')
measure1 = self._create_measure(plugin, instr=True)
core = self.workbench.get_plugin(u'enaml.workbench.core')
cmd = u'enaml.workbench.ui.select_workspace'
core.invoke_command(cmd, {'workspace': u'hqc_meas.measure.workspace'},
self)
workspace = plugin.workspace
plugin.selected_engine = u'engine1'
res = workspace.enqueue_measure(measure1)
assert_true(res)
workspace.start_processing_measures()
# Check the right flag is set in the plugin.
assert_in('processing', plugin.flags)
# Check an engine instance was created and is processing the measure.
assert_true(plugin.engine_instance)
engine = plugin.engine_instance
assert_true(engine.ready)
assert_true(engine.running)
# Check the plugin observe the done event.
assert_true(engine.has_observer('done', plugin._listen_to_engine))
# Check the measure has been registered as running and its status been
# updated.
assert_true(plugin.running_measure)
measure = plugin.running_measure
assert_equal(measure.status, 'RUNNING')
assert_equal(measure.infos, 'The measure is running')
# Check the monitors connections, that it started and received notif.
monitor = measure.monitors.values()[0]
assert_true(engine.has_observer('news', monitor.process_news))
assert_equal(monitor.black_box, ['Started'])
assert_equal(monitor.engine_news, {'root/default_path': 'test'})
# Check the instr profile is not available.
assert_not_in(' dummy ', instr_plugin.available_profiles)
assert_in(' dummy ', measure.root_task.run_time['profiles'])
# Make the engine send the done event.
engine.complete_measure()
# Check engine state.
assert_false(engine.active)
assert_false(engine.has_observers('news'))
# Check measure state.
assert_equal(measure.status, 'COMPLETED')
assert_equal(measure.infos, 'Measure successfully completed')
# Check plugin state.
assert_false(plugin.flags)
# Check instrument profile has been released.
assert_in(' dummy ', instr_plugin.available_profiles)
# Closing workspace.
core = self.workbench.get_plugin(u'enaml.workbench.core')
core.invoke_command(u'enaml.workbench.ui.close_workspace', {}, self)
# Check monitors stopped properly.
assert_equal(monitor.black_box, ['Started', 'Stopped'])
def test_measure_processing6(self):
# Test processing a measure using an instr, which has not tested the
# connection to the instr and not been re-edited.
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
instr_plugin = self.workbench.get_plugin('hqc_meas.instr_manager')
measure1 = self._create_measure(plugin, instr=True)
core = self.workbench.get_plugin(u'enaml.workbench.core')
cmd = u'enaml.workbench.ui.select_workspace'
core.invoke_command(cmd, {'workspace': u'hqc_meas.measure.workspace'},
self)
workspace = plugin.workspace
plugin.selected_engine = u'engine1'
res = workspace.enqueue_measure(measure1)
assert_true(res)
# Make everything looks like the instr has not been tested ie empty
# 'profile' entry in measure.store.
plugin.enqueued_measures[0].store['profiles'] = []
workspace.start_processing_measures()
# Check the right flag is set in the plugin.
assert_in('processing', plugin.flags)
# Check an engine instance was created and is processing the measure.
assert_true(plugin.engine_instance)
engine = plugin.engine_instance
assert_true(engine.ready)
assert_true(engine.running)
# Check the plugin observe the done event.
assert_true(engine.has_observer('done', plugin._listen_to_engine))
# Check the measure has been registered as running and its status been
# updated.
assert_true(plugin.running_measure)
measure = plugin.running_measure
assert_equal(measure.status, 'RUNNING')
assert_equal(measure.infos, 'The measure is running')
# Check the monitors connections, that it started and received notif.
monitor = measure.monitors.values()[0]
assert_true(engine.has_observer('news', monitor.process_news))
assert_equal(monitor.black_box, ['Started'])
assert_equal(monitor.engine_news, {'root/default_path': 'test'})
# Check the instr profile is not available.
assert_not_in(' dummy ', instr_plugin.available_profiles)
assert_in(' dummy ', measure.root_task.run_time['profiles'])
# Make the engine send the done event.
engine.complete_measure()
# Check engine state.
assert_false(engine.active)
assert_false(engine.has_observers('news'))
# Check measure state.
assert_equal(measure.status, 'COMPLETED')
assert_equal(measure.infos, 'Measure successfully completed')
# Check plugin state.
assert_false(plugin.flags)
# Check instrument profile has been released.
assert_in(' dummy ', instr_plugin.available_profiles)
# Closing workspace.
core = self.workbench.get_plugin(u'enaml.workbench.core')
core.invoke_command(u'enaml.workbench.ui.close_workspace', {}, self)
# Check monitors stopped properly.
assert_equal(monitor.black_box, ['Started', 'Stopped'])
def test_measure_processing7(self):
# Test processing a measure using an instr, which has tested the
# connection to the instr and been re-edited (ie no build-dep)
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
instr_plugin = self.workbench.get_plugin('hqc_meas.instr_manager')
measure1 = self._create_measure(plugin, instr=True)
core = self.workbench.get_plugin(u'enaml.workbench.core')
cmd = u'enaml.workbench.ui.select_workspace'
core.invoke_command(cmd, {'workspace': u'hqc_meas.measure.workspace'},
self)
workspace = plugin.workspace
plugin.selected_engine = u'engine1'
res = workspace.enqueue_measure(measure1)
assert_true(res)
# Make everything looks like the measure has been re-edited ie no
# build_deps entry in measure.store.
del plugin.enqueued_measures[0].store['build_deps']
workspace.start_processing_measures()
# Check the right flag is set in the plugin.
assert_in('processing', plugin.flags)
# Check an engine instance was created and is processing the measure.
assert_true(plugin.engine_instance)
engine = plugin.engine_instance
assert_true(engine.ready)
assert_true(engine.running)
# Check the plugin observe the done event.
assert_true(engine.has_observer('done', plugin._listen_to_engine))
# Check the measure has been registered as running and its status been
# updated.
assert_true(plugin.running_measure)
measure = plugin.running_measure
assert_equal(measure.status, 'RUNNING')
assert_equal(measure.infos, 'The measure is running')
# Check the monitors connections, that it started and received notif.
monitor = measure.monitors.values()[0]
assert_true(engine.has_observer('news', monitor.process_news))
assert_equal(monitor.black_box, ['Started'])
assert_equal(monitor.engine_news, {'root/default_path': 'test'})
# Check the instr profile is not available.
assert_not_in(' dummy ', instr_plugin.available_profiles)
assert_in(' dummy ', measure.root_task.run_time['profiles'])
# Make the engine send the done event.
engine.complete_measure()
# Check engine state.
assert_false(engine.active)
assert_false(engine.has_observers('news'))
# Check measure state.
assert_equal(measure.status, 'COMPLETED')
assert_equal(measure.infos, 'Measure successfully completed')
# Check plugin state.
assert_false(plugin.flags)
# Check instrument profile has been released.
assert_in(' dummy ', instr_plugin.available_profiles)
# Closing workspace.
core = self.workbench.get_plugin(u'enaml.workbench.core')
core.invoke_command(u'enaml.workbench.ui.close_workspace', {}, self)
# Check monitors stopped properly.
assert_equal(monitor.black_box, ['Started', 'Stopped'])
def test_processing_single_measure(self):
""" Test processing only a specific measure.
"""
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
measure1 = self._create_measure(plugin)
plugin.enqueued_measures.append(measure1)
measure2 = self._create_measure(plugin)
plugin.enqueued_measures.append(measure2)
measure3 = self._create_measure(plugin)
plugin.enqueued_measures.append(measure3)
core = self.workbench.get_plugin(u'enaml.workbench.core')
cmd = u'enaml.workbench.ui.select_workspace'
core.invoke_command(cmd, {'workspace': u'hqc_meas.measure.workspace'},
self)
workspace = plugin.workspace
plugin.selected_engine = u'engine1'
workspace.process_single_measure(measure2)
# Check the right flag is set in the plugin.
assert_in('processing', plugin.flags)
assert_in('stop_processing', plugin.flags)
# Check the measure has been registered as running and its status been
# updated.
assert_true(plugin.running_measure)
measure = plugin.running_measure
assert_equal(measure.status, 'RUNNING')
assert_equal(measure.infos, 'The measure is running')
assert_is(measure, measure2)
# Make the engine send the done event.
plugin.engine_instance.complete_measure()
# Check measures state.
assert_equal(measure1.status, 'READY')
assert_equal(measure2.status, 'COMPLETED')
assert_equal(measure3.status, 'READY')
# Check plugin state.
assert_false(plugin.flags)
assert_false(plugin.engine_instance.running)
def test_pause_measure1(self):
""" Test pausing a measure.
"""
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
measure1 = self._create_measure(plugin)
plugin.enqueued_measures.append(measure1)
core = self.workbench.get_plugin(u'enaml.workbench.core')
cmd = u'enaml.workbench.ui.select_workspace'
core.invoke_command(cmd, {'workspace': u'hqc_meas.measure.workspace'},
self)
workspace = plugin.workspace
plugin.selected_engine = u'engine1'
workspace.start_processing_measures()
# Pause the measure before it completes.
workspace.pause_current_measure()
assert_equal(measure1.status, 'PAUSED')
workspace.resume_current_measure()
assert_equal(measure1.status, 'RUNNING')
# Complete the second measure.
plugin.engine_instance.complete_measure()
# Check measures state.
assert_equal(measure1.status, 'COMPLETED')
# Check plugin state.
assert_false(plugin.flags)
assert_false(plugin.engine_instance.running)
def test_stop_measure(self):
""" Test stopping a measure but allowing to process next one.
"""
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
measure1 = self._create_measure(plugin)
plugin.enqueued_measures.append(measure1)
measure2 = self._create_measure(plugin)
plugin.enqueued_measures.append(measure2)
core = self.workbench.get_plugin(u'enaml.workbench.core')
cmd = u'enaml.workbench.ui.select_workspace'
core.invoke_command(cmd, {'workspace': u'hqc_meas.measure.workspace'},
self)
workspace = plugin.workspace
plugin.selected_engine = u'engine1'
workspace.start_processing_measures()
# Stop the measure before it completes.
workspace.stop_current_measure()
# Complete the second measure.
plugin.engine_instance.complete_measure()
# Check measures state.
assert_equal(measure1.status, 'INTERRUPTED')
assert_equal(measure2.status, 'COMPLETED')
# Check plugin state.
assert_false(plugin.flags)
assert_false(plugin.engine_instance.running)
def test_stop_processing(self):
""" Test stopping the whole processing loop.
"""
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
measure1 = self._create_measure(plugin)
plugin.enqueued_measures.append(measure1)
measure2 = self._create_measure(plugin)
plugin.enqueued_measures.append(measure2)
core = self.workbench.get_plugin(u'enaml.workbench.core')
cmd = u'enaml.workbench.ui.select_workspace'
core.invoke_command(cmd, {'workspace': u'hqc_meas.measure.workspace'},
self)
workspace = plugin.workspace
plugin.selected_engine = u'engine1'
workspace.start_processing_measures()
# Stop the measure before it completes.
workspace.stop_processing_measures()
# Check measures state.
assert_equal(measure1.status, 'INTERRUPTED')
assert_equal(measure2.status, 'READY')
# Check plugin state.
assert_false(plugin.flags)
assert_false(plugin.engine_instance.running)
def test_exit_measure(self):
""" Test stopping a measure (force) but allowing to process next one.
"""
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
measure1 = self._create_measure(plugin)
plugin.enqueued_measures.append(measure1)
measure2 = self._create_measure(plugin)
plugin.enqueued_measures.append(measure2)
core = self.workbench.get_plugin(u'enaml.workbench.core')
cmd = u'enaml.workbench.ui.select_workspace'
core.invoke_command(cmd, {'workspace': u'hqc_meas.measure.workspace'},
self)
workspace = plugin.workspace
plugin.selected_engine = u'engine1'
workspace.start_processing_measures()
plugin.engine_instance.allow_stop = False
workspace.stop_current_measure()
# Check the plugin flags.
assert_in('stop_attempt', plugin.flags)
# Force stop the measure before it completes.
workspace.force_stop_measure()
# Complete the second measure.
plugin.engine_instance.allow_stop = True
plugin.engine_instance.complete_measure()
# Check measures state.
assert_equal(measure1.status, 'INTERRUPTED')
assert_equal(measure2.status, 'COMPLETED')
# Check plugin state.
assert_false(plugin.flags)
assert_false(plugin.engine_instance.running)
def test_exit_processing(self):
""" Test stopping the whole processing loop (force).
"""
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
measure1 = self._create_measure(plugin)
plugin.enqueued_measures.append(measure1)
measure2 = self._create_measure(plugin)
plugin.enqueued_measures.append(measure2)
core = self.workbench.get_plugin(u'enaml.workbench.core')
cmd = u'enaml.workbench.ui.select_workspace'
core.invoke_command(cmd, {'workspace': u'hqc_meas.measure.workspace'},
self)
workspace = plugin.workspace
plugin.selected_engine = u'engine1'
workspace.start_processing_measures()
plugin.engine_instance.allow_stop = False
workspace.stop_current_measure()
# Check the plugin flags.
assert_in('stop_attempt', plugin.flags)
# Force stop the processing.
workspace.force_stop_processing()
# Check measures state.
assert_equal(measure1.status, 'INTERRUPTED')
assert_equal(measure2.status, 'READY')
# Check plugin state.
assert_false(plugin.flags)
assert_false(plugin.engine_instance.running)
def _create_measure(self, plugin, instr=False):
""" Create a measure.
"""
measure = Measure(plugin=plugin, name='Test1')
measure.root_task = RootTask(default_path=self.test_dir)
if instr:
false_instr_user = FalseInstrTask(selected_profile=' dummy ',
selected_driver='PanelTestDummy')
measure.root_task.children_task = [false_instr_user]
measure.status = 'READY'
monitor_decl = plugin.monitors[u'monitor1']
measure.add_monitor(monitor_decl.id,
monitor_decl.factory(monitor_decl, self.workbench))
return measure
class TestPNASetRFFrequencyView(object):
def setup(self):
self.workbench = Workbench()
self.workbench.register(CoreManifest())
self.workbench.register(StateManifest())
self.workbench.register(PreferencesManifest())
self.workbench.register(InstrManagerManifest())
self.workbench.register(TaskManagerManifest())
self.root = RootTask(should_stop=Event(), should_pause=Event())
self.task = SetRFFrequencyTask(task_name='Test')
self.root.children_task.append(self.task)
self.root.run_time['drivers'] = {'Test': InstrHelper}
def teardown(self):
close_all_windows()
self.workbench.unregister(u'hqc_meas.task_manager')
self.workbench.unregister(u'hqc_meas.instr_manager')
self.workbench.unregister(u'hqc_meas.preferences')
self.workbench.unregister(u'hqc_meas.state')
self.workbench.unregister(u'enaml.workbench.core')
def test_view1(self):
# Intantiate a view with no selected interface and select one after
window = enaml.widgets.api.Window()
core = self.workbench.get_plugin('enaml.workbench.core')
view = RFFrequencyView(window, task=self.task, core=core)
window.show()
process_app_events()
assert_in('AgilentPNA', view.drivers)
self.task.selected_driver = 'AgilentPNA'
process_app_events()
assert_is_instance(self.task.interface, PNASetRFFrequencyInterface)
def test_view2(self):
# Intantiate a view with a selected interface.
self.task.interface = PNASetRFFrequencyInterface(task=self.task)
self.task.frequency = '1.0'
self.task.selected_driver = 'AgilentPNA'
interface = self.task.interface
window = enaml.widgets.api.Window()
core = self.workbench.get_plugin('enaml.workbench.core')
RFFrequencyView(window, task=self.task, core=core)
window.show()
process_app_events()
assert_is(self.task.interface, interface)
class TestProcessEngine(object):
test_dir = ''
@classmethod
def setup_class(cls):
print complete_line(__name__ +
':{}.setup_class()'.format(cls.__name__), '-', 77)
# Creating dummy directory for prefs (avoid prefs interferences).
directory = os.path.dirname(__file__)
cls.test_dir = os.path.join(directory, '_temps')
create_test_dir(cls.test_dir)
# Creating dummy default.ini file in utils.
util_path = os.path.join(directory, '..', '..', '..', 'hqc_meas',
'utils', 'preferences')
def_path = os.path.join(util_path, 'default.ini')
# Making the preference manager look for info in test dir.
default = ConfigObj(def_path)
default['folder'] = cls.test_dir
default['file'] = 'default_test.ini'
default.write()
conf = ConfigObj(os.path.join(cls.test_dir, 'default_test.ini'))
conf[u'hqc_meas.measure'] = {}
conf.write()
@classmethod
def teardown_class(cls):
print complete_line(__name__ +
':{}.teardown_class()'.format(cls.__name__), '-',
77)
# Removing pref files creating during tests.
remove_tree(cls.test_dir)
# Restoring default.ini file in utils
directory = os.path.dirname(__file__)
util_path = os.path.join(directory, '..', '..', '..', 'hqc_meas',
'utils', 'preferences')
def_path = os.path.join(util_path, 'default.ini')
os.remove(def_path)
aux = os.path.join(util_path, '__default.ini')
if os.path.isfile(aux):
os.rename(aux, def_path)
def setup(self):
self.workbench = Workbench()
self.workbench.register(CoreManifest())
self.workbench.register(UIManifest())
self.workbench.register(HqcAppManifest())
self.workbench.register(StateManifest())
self.workbench.register(PreferencesManifest())
self.workbench.register(LogManifest())
self.workbench.register(TaskManagerManifest())
self.workbench.register(InstrManagerManifest())
self.workbench.register(MeasureManifest())
self.workbench.register(TestSuiteManifest())
def teardown(self):
core = self.workbench.get_plugin(u'enaml.workbench.core')
core.invoke_command(u'enaml.workbench.ui.close_workspace', {}, self)
self.workbench.unregister(u'tests.suite')
self.workbench.unregister(u'hqc_meas.measure')
self.workbench.unregister(u'hqc_meas.task_manager')
self.workbench.unregister(u'hqc_meas.instr_manager')
self.workbench.unregister(u'hqc_meas.logging')
self.workbench.unregister(u'hqc_meas.preferences')
self.workbench.unregister(u'hqc_meas.state')
self.workbench.unregister(u'hqc_meas.app')
self.workbench.unregister(u'enaml.workbench.ui')
self.workbench.unregister(u'enaml.workbench.core')
def test_find_view1(self):
""" Test finding a view for an existing task.
"""
editor = StandardEditor(workbench=self.workbench)
editor.selected_task = None
editor.selected_task = RootTask()
assert_is_instance(editor._internal.current_view, RootView)
def test_find_view2(self):
""" Test finding a view for a non-existing task.
"""
editor = StandardEditor(workbench=self.workbench)
class Toto(RootTask):
pass
editor.selected_task = None
editor.selected_task = Toto()
assert_is_instance(editor._internal.current_view, FailureView)
def initialize_default(extra_manifests, workspace='psi.experiment.workspace'):
with enaml.imports():
from enaml.workbench.core.core_manifest import CoreManifest
from enaml.workbench.ui.ui_manifest import UIManifest
from psi.context.manifest import ContextManifest
from psi.data.manifest import DataManifest
from psi.experiment.manifest import ExperimentManifest
with warnings.catch_warnings():
warnings.simplefilter('ignore')
workbench = Workbench()
workbench.register(CoreManifest())
workbench.register(UIManifest())
workbench.register(ContextManifest())
workbench.register(DataManifest())
workbench.register(ExperimentManifest())
for manifest in extra_manifests:
workbench.register(manifest())
core = workbench.get_plugin('enaml.workbench.core')
ui = workbench.get_plugin('enaml.workbench.ui')
ui.show_window()
core.invoke_command('enaml.workbench.ui.select_workspace',
{'workspace': workspace})
experiment = workbench.get_plugin('psi.experiment')
return workbench
def setup(self):
self.workbench = Workbench()
class Test_Prefs(object):
test_dir = ''
@classmethod
def setup_class(cls):
print complete_line(
__name__ + ':{}.setup_class()'.format(cls.__name__), '-', 77)
@classmethod
def teardown_class(cls):
print complete_line(
__name__ + ':{}.teardown_class()'.format(cls.__name__), '-', 77)
def setup(self):
self.workbench = Workbench()
def test_closing(self):
""" Test that validation stops as soon as the event is rejected.
"""
self.workbench.register(HqcAppManifest())
self.workbench.register(ClosingContributor1())
self.workbench.register(ClosingContributor2())
manifest1 = self.workbench.get_manifest('test.closing')
manifest2 = self.workbench.get_manifest('test.closing2')
window = Helper(self.workbench)
plugin = self.workbench.get_plugin('hqc_meas.app')
ev = CloseEvent()
plugin.validate_closing(window, ev)
assert_false(ev.is_accepted())
assert_false(manifest2.called)
manifest1.accept = True
manifest2.accept = True
plugin.validate_closing(window, ev)
assert_true(ev.is_accepted())
assert_true(manifest2.called)
self.workbench.unregister(u'test.closing')
self.workbench.unregister(u'hqc_meas.app')
def test_check_registation1(self):
""" Test that ClosingApp are properly found at start-up.
"""
self.workbench.register(HqcAppManifest())
self.workbench.register(ClosingContributor1())
plugin = self.workbench.get_plugin('hqc_meas.app')
assert_equal(len(plugin._closing_extensions), 1)
assert_equal(len(plugin._closing_checks), 1)
self.workbench.unregister(u'test.closing')
assert_false(plugin._closing_extensions)
assert_false(plugin._closing_checks)
self.workbench.unregister(u'hqc_meas.app')
def test_check_registration2(self):
""" Test ClosingApp update when a new plugin is registered.
"""
self.workbench.register(HqcAppManifest())
plugin = self.workbench.get_plugin('hqc_meas.app')
assert_false(plugin._closing_extensions)
assert_false(plugin._closing_checks)
self.workbench.register(ClosingContributor1())
assert_equal(len(plugin._closing_extensions), 1)
assert_equal(len(plugin._closing_checks), 1)
self.workbench.register(ClosingContributor1ter())
assert_equal(len(plugin._closing_extensions), 2)
assert_equal(len(plugin._closing_checks), 2)
self.workbench.unregister(u'test.closing')
self.workbench.unregister(u'hqc_meas.app')
def test_check_factory(self):
""" Test getting the ClosingApp decl from a factory.
"""
self.workbench.register(HqcAppManifest())
self.workbench.register(ClosingContributor2())
plugin = self.workbench.get_plugin('hqc_meas.app')
assert_equal(len(plugin._closing_extensions), 1)
assert_equal(len(plugin._closing_checks), 1)
self.workbench.unregister(u'test.closing2')
assert_false(plugin._closing_extensions)
assert_false(plugin._closing_checks)
self.workbench.unregister(u'hqc_meas.app')
@raises(ValueError)
def test_check_errors1(self):
""" Test uniqueness of ClosingApp id.
"""
self.workbench.register(HqcAppManifest())
self.workbench.get_plugin(u'hqc_meas.app')
self.workbench.register(ClosingContributor1())
self.workbench.register(ClosingContributor1bis())
@raises(ValueError)
def test_check_errors2(self):
""" Test presence of validate in ClosingApp.
"""
self.workbench.register(HqcAppManifest())
self.workbench.register(ClosingContributor3())
self.workbench.get_plugin(u'hqc_meas.app')
@raises(TypeError)
def test_check_errors3(self):
""" Test enforcement of type for ClosingApp when using factory.
"""
self.workbench.register(HqcAppManifest())
self.workbench.register(ClosingContributor4())
self.workbench.get_plugin(u'hqc_meas.app')
class TestProcessEngine(object):
test_dir = ''
@classmethod
def setup_class(cls):
print complete_line(
__name__ + ':{}.setup_class()'.format(cls.__name__), '-', 77)
# Creating dummy directory for prefs (avoid prefs interferences).
directory = os.path.dirname(__file__)
cls.test_dir = os.path.join(directory, '_temps')
create_test_dir(cls.test_dir)
# Creating dummy default.ini file in utils.
util_path = os.path.join(directory, '..', '..', '..', 'hqc_meas',
'utils', 'preferences')
def_path = os.path.join(util_path, 'default.ini')
# Making the preference manager look for info in test dir.
default = ConfigObj(def_path)
default['folder'] = cls.test_dir
default['file'] = 'default_test.ini'
default.write()
conf = ConfigObj(os.path.join(cls.test_dir, 'default_test.ini'))
path = 'hqc_meas.measurement.engines.process_engine'
prefs = {'manifests': repr([(path, 'ProcessEngineManifest')])}
conf[u'hqc_meas.measure'] = prefs
conf.write()
@classmethod
def teardown_class(cls):
print complete_line(
__name__ + ':{}.teardown_class()'.format(cls.__name__), '-', 77)
# Removing pref files creating during tests.
remove_tree(cls.test_dir)
# Restoring default.ini file in utils
directory = os.path.dirname(__file__)
util_path = os.path.join(directory, '..', '..', '..', 'hqc_meas',
'utils', 'preferences')
def_path = os.path.join(util_path, 'default.ini')
os.remove(def_path)
aux = os.path.join(util_path, '__default.ini')
if os.path.isfile(aux):
os.rename(aux, def_path)
def setup(self):
self.workbench = Workbench()
self.workbench.register(CoreManifest())
self.workbench.register(UIManifest())
self.workbench.register(HqcAppManifest())
self.workbench.register(StateManifest())
self.workbench.register(PreferencesManifest())
self.workbench.register(LogManifest())
self.workbench.register(DependenciesManifest())
self.workbench.register(TaskManagerManifest())
self.workbench.register(InstrManagerManifest())
self.workbench.register(MeasureManifest())
self.workbench.register(TestSuiteManifest())
def teardown(self):
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
engine = plugin.engine_instance
if engine and engine._process and engine._process.is_alive():
engine._process.terminate()
core = self.workbench.get_plugin(u'enaml.workbench.core')
core.invoke_command(u'enaml.workbench.ui.close_workspace', {}, self)
self.workbench.unregister(u'tests.suite')
self.workbench.unregister(u'hqc_meas.measure')
self.workbench.unregister(u'hqc_meas.task_manager')
self.workbench.unregister(u'hqc_meas.instr_manager')
self.workbench.unregister(u'hqc_meas.logging')
self.workbench.unregister(u'hqc_meas.dependencies')
self.workbench.unregister(u'hqc_meas.preferences')
self.workbench.unregister(u'hqc_meas.state')
self.workbench.unregister(u'hqc_meas.app')
self.workbench.unregister(u'enaml.workbench.ui')
self.workbench.unregister(u'enaml.workbench.core')
def test_workspace_contribution(self):
""" Test that the process does contribute to the workspace.
"""
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
plugin.selected_engine = u'hqc_meas.measure.engines.process_engine'
core = self.workbench.get_plugin(u'enaml.workbench.core')
cmd = u'enaml.workbench.ui.select_workspace'
core.invoke_command(cmd, {'workspace': u'hqc_meas.measure.workspace'},
self)
process_app_events()
log_plugin = self.workbench.get_plugin(u'hqc_meas.logging')
# Check the presence of the filters and handler in the log.
assert_in(u'hqc_meas.measure.workspace.process_engine',
log_plugin.filter_ids)
assert_in(u'hqc_meas.measure.engines.process_engine',
log_plugin.filter_ids)
assert_in(u'hqc_meas.measure.engines.process_engine',
log_plugin.handler_ids)
# Check the presence of the dock item.
assert_true(plugin.workspace.dock_area.find('subprocess_log'))
dock_item = plugin.workspace.dock_area.find('subprocess_log')
assert_equal(dock_item.model.text, u'')
# Unselected the engine.
plugin.selected_engine = ''
# Check the absence of the filters and handler in the log.
assert_not_in(u'hqc_meas.measure.workspace.process_engine',
log_plugin.filter_ids)
assert_not_in(u'hqc_meas.measure.engines.process_engine',
log_plugin.filter_ids)
assert_not_in(u'hqc_meas.measure.engines.process_engine',
log_plugin.handler_ids)
# Check the presence of the dock item.
assert_false(plugin.workspace.dock_area.find('process_log'))
def test_measure_processing1(self):
""" Test the processing of a single measure (using the plugin).
Test the communication with the plugin.
"""
counter = 0
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
measure = self._create_measure(plugin)
plugin.enqueued_measures.append(measure)
core = self.workbench.get_plugin(u'enaml.workbench.core')
cmd = u'enaml.workbench.ui.select_workspace'
core.invoke_command(cmd, {'workspace': u'hqc_meas.measure.workspace'},
self)
workspace = plugin.workspace
plugin.selected_engine = u'hqc_meas.measure.engines.process_engine'
workspace.start_processing_measures()
# Check the engine state.
engine = plugin.engine_instance
assert_true(engine.active)
while not engine._processing.is_set():
sleep(0.1)
counter += 1
if counter > 100:
raise Exception('Engine took too long to start.')
while engine._processing.is_set():
process_app_events()
sleep(0.1)
counter += 1
if counter > 200:
raise Exception('Task took too long to complete.')
sleep(0.1)
process_app_events()
assert_equal(measure.status, 'COMPLETED')
while engine.active:
sleep(0.1)
counter += 1
if counter > 300:
raise Exception('Engine took too long to exit.')
# Check the engine exited properly.
assert_false(engine._force_stop.is_set())
# Check log.
process_app_events()
assert_not_in('test', workspace.log_model.text)
assert_in('test',
workspace.dock_area.find('subprocess_log').model.text)
# For some tests don't need to use the plugin to start, stop the engine.
def test_measure_processing2(self):
""" Test the processing of a single measure (not using the plugin).
Test the communication with the monitors (skip plugin tests) and with
the log.
"""
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
measure = self._create_measure(plugin)
monitor = measure.monitors.values()[0]
core = self.workbench.get_plugin('enaml.workbench.core')
cmd = 'hqc_meas.dependencies.collect_dependencies'
_, b_deps = core.invoke_command(cmd, {
'obj': measure.root_task,
'dependencies': ['build']
})
engine = ProcessEngine(workbench=self.workbench)
engine.observe('news', measure.monitors.values()[0].process_news)
engine.prepare_to_run('test', measure.root_task,
measure.collect_entries_to_observe(), b_deps)
monitor.start(None)
# Check engine state.
assert_true(engine._temp)
assert_false(engine._meas_stop.is_set())
assert_false(engine._stop.is_set())
assert_false(engine._force_stop.is_set())
assert_true(engine._process and engine._process.daemon)
assert_true(engine._pipe)
assert_true(engine._monitor_thread and engine._monitor_thread.daemon)
assert_true(engine._log_thread and engine._log_thread.daemon)
# Start the measure.
engine.run()
assert_true(engine.active)
i = 0
while not engine._processing.is_set():
sleep(0.1)
i += 1
if i > 100:
raise Exception('Engine took too long to start.')
while i != 0 and engine._processing.is_set():
sleep(0.1)
i += 1
if i > 200:
raise Exception('Task took too long to complete.')
engine.exit()
while engine.active:
sleep(0.1)
i += 1
if i > 300:
raise Exception('Engine took too long to exit.')
# Check the monitor and log received the notifications.
assert_in('root/print_message', monitor.engine_news)
assert_equal(monitor.engine_news['root/print_message'], 'test')
def test_measure_processing3(self):
""" Test the processing of a measure failing the tests.
Not terribly interesting just increase coverage but does not allow
any true check.
"""
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
measure = self._create_measure(plugin)
measure.root_task.default_path = ''
core = self.workbench.get_plugin('enaml.workbench.core')
cmd = 'hqc_meas.dependencies.collect_dependencies'
_, b_deps = core.invoke_command(cmd, {
'obj': measure.root_task,
'dependencies': ['build']
})
engine = ProcessEngine(workbench=self.workbench)
engine.prepare_to_run('test', measure.root_task,
measure.collect_entries_to_observe(), b_deps)
# Check engine state.
assert_true(engine._temp)
assert_false(engine._meas_stop.is_set())
assert_false(engine._stop.is_set())
assert_false(engine._force_stop.is_set())
assert_true(engine._process and engine._process.daemon)
assert_true(engine._pipe)
assert_true(engine._monitor_thread and engine._monitor_thread.daemon)
assert_true(engine._log_thread and engine._log_thread.daemon)
# Start the measure.
engine.run()
sleep(2)
engine.exit()
def test_pausing_measure1(self):
""" Test pausing and resuming a measure.
"""
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
measure1 = self._create_measure(plugin)
plugin.enqueued_measures.append(measure1)
core = self.workbench.get_plugin(u'enaml.workbench.core')
cmd = u'enaml.workbench.ui.select_workspace'
core.invoke_command(cmd, {'workspace': u'hqc_meas.measure.workspace'},
self)
workspace = plugin.workspace
plugin.selected_engine = u'hqc_meas.measure.engines.process_engine'
workspace.start_processing_measures()
i = 0
while not plugin.engine_instance._processing.is_set():
sleep(0.1)
i += 1
if i > 100:
raise Exception('Task took too long to start.')
# Pause the measure before it completes.
workspace.pause_current_measure()
process_app_events()
assert_equal(measure1.status, 'PAUSING')
i = 0
while measure1.status != 'PAUSED':
process_app_events()
sleep(0.1)
i += 1
if i > 100:
raise Exception('Task took too long to paused.')
process_app_events()
workspace.resume_current_measure()
process_app_events()
assert_equal(measure1.status, 'RUNNING')
while plugin.engine_instance._processing.is_set():
process_app_events()
sleep(0.1)
i += 1
if i > 200:
raise Exception('Task took too long to complete.')
sleep(0.1)
process_app_events()
assert_equal(measure1.status, 'COMPLETED')
def test_pausing_measure2(self):
""" Test pausing and stopping a measure.
"""
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
measure1 = self._create_measure(plugin)
plugin.enqueued_measures.append(measure1)
core = self.workbench.get_plugin(u'enaml.workbench.core')
cmd = u'enaml.workbench.ui.select_workspace'
core.invoke_command(cmd, {'workspace': u'hqc_meas.measure.workspace'},
self)
workspace = plugin.workspace
plugin.selected_engine = u'hqc_meas.measure.engines.process_engine'
workspace.start_processing_measures()
i = 0
while not plugin.engine_instance._processing.is_set():
sleep(0.1)
i += 1
if i > 100:
raise Exception('Task took too long to start.')
# Pause the measure before it completes.
workspace.pause_current_measure()
process_app_events()
assert_equal(measure1.status, 'PAUSING')
i = 0
while measure1.status != 'PAUSED':
process_app_events()
sleep(0.1)
i += 1
if i > 100:
raise Exception('Task took too long to pause.')
process_app_events()
# Stop the measure before it completes.
workspace.stop_current_measure()
i = 0
while plugin.engine_instance._processing.is_set():
sleep(0.1)
i += 1
if i > 100:
raise Exception('Task took too long to complete.')
process_app_events()
# Check measures state.
assert_equal(measure1.status, 'INTERRUPTED')
def test_stop_measure(self):
""" Test stopping a measure but allowing to process next one.
"""
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
measure1 = self._create_measure(plugin)
plugin.enqueued_measures.append(measure1)
core = self.workbench.get_plugin(u'enaml.workbench.core')
cmd = u'enaml.workbench.ui.select_workspace'
core.invoke_command(cmd, {'workspace': u'hqc_meas.measure.workspace'},
self)
workspace = plugin.workspace
plugin.selected_engine = u'hqc_meas.measure.engines.process_engine'
workspace.start_processing_measures()
i = 0
while not plugin.engine_instance._processing.is_set():
sleep(0.1)
i += 1
if i > 100:
raise Exception('Task took too long to start.')
# Stop the measure before it completes.
workspace.stop_current_measure()
i = 0
while plugin.engine_instance._processing.is_set():
sleep(0.1)
i += 1
if i > 100:
raise Exception('Task took too long to complete.')
process_app_events()
# Check measures state.
assert_equal(measure1.status, 'INTERRUPTED')
def test_stop_processing(self):
""" Test stopping the whole processing loop.
"""
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
measure1 = self._create_measure(plugin)
plugin.enqueued_measures.append(measure1)
measure2 = self._create_measure(plugin)
plugin.enqueued_measures.append(measure2)
core = self.workbench.get_plugin(u'enaml.workbench.core')
cmd = u'enaml.workbench.ui.select_workspace'
core.invoke_command(cmd, {'workspace': u'hqc_meas.measure.workspace'},
self)
workspace = plugin.workspace
plugin.selected_engine = u'hqc_meas.measure.engines.process_engine'
workspace.start_processing_measures()
i = 0
while not plugin.engine_instance._processing.is_set():
sleep(0.1)
i += 1
if i > 100:
raise Exception('Task took too long to start.')
# Stop the measure before it completes.
workspace.stop_processing_measures()
i = 0
while plugin.engine_instance._processing.is_set():
sleep(0.1)
i += 1
if i > 100:
raise Exception('Task took too long to complete.')
process_app_events()
# Check measures state.
assert_equal(measure1.status, 'INTERRUPTED')
assert_equal(measure2.status, 'READY')
def test_exit_measure(self):
""" Test stopping a measure (force) but allowing to process next one.
"""
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
measure1 = self._create_measure(plugin)
plugin.enqueued_measures.append(measure1)
core = self.workbench.get_plugin(u'enaml.workbench.core')
cmd = u'enaml.workbench.ui.select_workspace'
core.invoke_command(cmd, {'workspace': u'hqc_meas.measure.workspace'},
self)
workspace = plugin.workspace
plugin.selected_engine = u'hqc_meas.measure.engines.process_engine'
workspace.start_processing_measures()
i = 0
while not plugin.engine_instance._processing.is_set():
sleep(0.1)
i += 1
if i > 100:
raise Exception('Task took too long to complete.')
# Force stop the measure before it completes.
workspace.force_stop_measure()
i = 0
while plugin.engine_instance._processing.is_set():
sleep(0.1)
i += 1
if i > 100:
raise Exception('Task took too long to complete.')
process_app_events()
# Check measures state.
assert_equal(measure1.status, 'INTERRUPTED')
def test_exit_processing(self):
""" Test stopping the whole processing loop (force).
"""
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
measure1 = self._create_measure(plugin)
plugin.enqueued_measures.append(measure1)
core = self.workbench.get_plugin(u'enaml.workbench.core')
cmd = u'enaml.workbench.ui.select_workspace'
core.invoke_command(cmd, {'workspace': u'hqc_meas.measure.workspace'},
self)
workspace = plugin.workspace
plugin.selected_engine = u'hqc_meas.measure.engines.process_engine'
workspace.start_processing_measures()
i = 0
while not plugin.engine_instance._processing.is_set():
sleep(0.1)
i += 1
if i > 100:
raise Exception('Task took too long to start.')
# Force stop the processing.
workspace.force_stop_processing()
i = 0
while plugin.engine_instance._processing.is_set():
sleep(0.1)
i += 1
if i > 100:
raise Exception('Task took too long to complete.')
process_app_events()
# Check measures state.
assert_equal(measure1.status, 'INTERRUPTED')
def _create_measure(self, plugin):
""" Create a measure.
"""
measure = Measure(plugin=plugin, name='Test1')
measure.root_task = RootTask(default_path=self.test_dir)
children = [
SleepTask(task_name='sleep1', time=1),
LogTask(task_name='print', message='test'),
SleepTask(task_name='sleep2', time=0.1)
]
measure.root_task.children_task.extend(children)
measure.status = 'READY'
monitor_decl = plugin.monitors[u'monitor1']
measure.add_monitor(monitor_decl.id,
monitor_decl.factory(monitor_decl, self.workbench))
return measure
def pulses_workbench(monkeypatch, app_dir):
"""Setup the workbench in such a way that the pulses manager can be tested.
"""
monkeypatch.setattr(ErrorsPlugin, 'exit_error_gathering', exit_on_err)
workbench = Workbench()
workbench.register(CoreManifest())
workbench.register(AppManifest())
workbench.register(PreferencesManifest())
workbench.register(ErrorsManifest())
workbench.register(StateManifest())
workbench.register(DependenciesManifest())
workbench.register(MeasureManifest())
workbench.register(PulsesManagerManifest())
yield workbench
for m_id in ('exopy.pulses', 'exopy.app.dependencies', 'exopy.app.errors',
'exopy.app.preferences', 'exopy.app'):
try:
workbench.unregister(m_id)
except Exception:
pass
def setup(self):
self.workbench = Workbench()
self.workbench.register(CoreManifest())
self.workbench.register(ErrorsManifest())
self.workbench.register(DeclaratorManifest())
class TestDebugSpace(object):
test_dir = ""
@classmethod
def setup_class(cls):
print complete_line(__name__ + ":{}.setup_class()".format(cls.__name__), "-", 77)
# Creating dummy directory for prefs (avoid prefs interferences).
directory = os.path.dirname(__file__)
cls.test_dir = os.path.join(directory, "_temps")
create_test_dir(cls.test_dir)
# Creating dummy default.ini file in utils.
util_path = os.path.join(directory, "..", "..", "hqc_meas", "utils", "preferences")
def_path = os.path.join(util_path, "default.ini")
# Making the preference manager look for info in test dir.
default = ConfigObj(def_path)
default["folder"] = cls.test_dir
default["file"] = "default_test.ini"
default.write()
conf = ConfigObj(os.path.join(cls.test_dir, "default_test.ini"))
conf.write()
@classmethod
def teardown_class(cls):
print complete_line(__name__ + ":{}.teardown_class()".format(cls.__name__), "-", 77)
# Removing pref files creating during tests.
remove_tree(cls.test_dir)
# Restoring default.ini file in utils
directory = os.path.dirname(__file__)
util_path = os.path.join(directory, "..", "..", "hqc_meas", "utils", "preferences")
def_path = os.path.join(util_path, "default.ini")
os.remove(def_path)
def setup(self):
self.workbench = Workbench()
self.workbench.register(CoreManifest())
self.workbench.register(UIManifest())
self.workbench.register(HqcAppManifest())
self.workbench.register(StateManifest())
self.workbench.register(PreferencesManifest())
self.workbench.register(LogManifest())
self.workbench.register(TaskManagerManifest())
self.workbench.register(InstrManagerManifest())
self.workbench.register(DebuggerManifest())
self.workbench.register(TestSuiteManifest())
def teardown(self):
core = self.workbench.get_plugin(u"enaml.workbench.core")
core.invoke_command(u"enaml.workbench.ui.close_workspace", {}, self)
self.workbench.unregister(u"hqc_meas.debug")
self.workbench.unregister(u"tests.suite")
self.workbench.unregister(u"hqc_meas.task_manager")
self.workbench.unregister(u"hqc_meas.instr_manager")
self.workbench.unregister(u"hqc_meas.logging")
self.workbench.unregister(u"hqc_meas.preferences")
self.workbench.unregister(u"hqc_meas.state")
self.workbench.unregister(u"hqc_meas.app")
self.workbench.unregister(u"enaml.workbench.ui")
self.workbench.unregister(u"enaml.workbench.core")
close_all_windows()
def test_life_cycle1(self):
""" Test that workspace starting/closing goes well.
"""
plugin = self.workbench.get_plugin(u"hqc_meas.debug")
core = self.workbench.get_plugin(u"enaml.workbench.core")
cmd = u"enaml.workbench.ui.select_workspace"
core.invoke_command(cmd, {"workspace": u"hqc_meas.debug.workspace"}, self)
log_plugin = self.workbench.get_plugin(u"hqc_meas.logging")
# Check the plugin got the workspace
assert_true(plugin.workspace)
workspace = plugin.workspace
# Check the contribution of the debugger was added to the workspace.
assert_true(tester.contributing)
ui = self.workbench.get_plugin("enaml.workbench.ui")
ui.show_window()
process_app_events()
# Check the workspace registration.
assert_true(workspace.log_model)
assert_in(LOG_ID, log_plugin.handler_ids)
logger = logging.getLogger(__name__)
logger.info("test")
process_app_events()
assert_in("test", workspace.log_model.text)
cmd = u"enaml.workbench.ui.close_workspace"
core.invoke_command(cmd, {}, self)
# Check the workspace removed its log handler.
assert_not_in(LOG_ID, log_plugin.handler_ids)
# Check the reference to the workspace was destroyed.
assert_equal(plugin.workspace, None)
# Check the contribution of the debugger to the workspace was removed.
assert_false(tester.contributing)
def test_life_cycle2(self):
""" Test that workspace reselection do restore debug panels.
"""
plugin = self.workbench.get_plugin(u"hqc_meas.debug")
core = self.workbench.get_plugin(u"enaml.workbench.core")
cmd = u"enaml.workbench.ui.select_workspace"
core.invoke_command(cmd, {"workspace": u"hqc_meas.debug.workspace"}, self)
# Check the plugin got the workspace
assert_true(plugin.workspace)
workspace = plugin.workspace
ui = self.workbench.get_plugin("enaml.workbench.ui")
ui.show_window()
process_app_events()
# Creating debuggers.
workspace.create_debugger("debugger1")
process_app_events()
workspace.create_debugger("debugger1")
process_app_events()
d_view1 = workspace.dock_area.find("item_1")
assert_is_instance(d_view1, TestDebuggerView)
d_view2 = workspace.dock_area.find("item_2")
assert_is_instance(d_view2, TestDebuggerView)
del workspace
# Closing workspace
cmd = u"enaml.workbench.ui.close_workspace"
core.invoke_command(cmd, {}, self)
process_app_events()
# Check the debugger released their ressources.
for debugger in plugin.debugger_instances:
assert_true(debugger.released)
# Reopening workspace.
cmd = u"enaml.workbench.ui.select_workspace"
core.invoke_command(cmd, {"workspace": u"hqc_meas.debug.workspace"}, self)
process_app_events()
workspace = plugin.workspace
# Checking the debuggers are there.
dock_area = workspace.dock_area
d_view1 = dock_area.find("item_1")
assert_is_instance(d_view1, TestDebuggerView)
d_view2 = dock_area.find("item_2")
assert_is_instance(d_view2, TestDebuggerView)
def test_create_debugger1(self):
""" Creating a debugger.
"""
plugin = self.workbench.get_plugin(u"hqc_meas.debug")
core = self.workbench.get_plugin(u"enaml.workbench.core")
cmd = u"enaml.workbench.ui.select_workspace"
core.invoke_command(cmd, {"workspace": u"hqc_meas.debug.workspace"}, self)
# Check the plugin got the workspace
assert_true(plugin.workspace)
workspace = plugin.workspace
ui = self.workbench.get_plugin("enaml.workbench.ui")
ui.show_window()
process_app_events()
workspace.create_debugger("debugger1")
process_app_events()
assert_true(plugin.debugger_instances)
assert_is_instance(plugin.debugger_instances[0], TestDebugger)
dock_area = workspace.dock_area
d_view = dock_area.find("item_1")
assert_is_instance(d_view, TestDebuggerView)
def test_create_debugger2(self):
""" Creating a debugger with wrong id.
"""
plugin = self.workbench.get_plugin(u"hqc_meas.debug")
core = self.workbench.get_plugin(u"enaml.workbench.core")
cmd = u"enaml.workbench.ui.select_workspace"
core.invoke_command(cmd, {"workspace": u"hqc_meas.debug.workspace"}, self)
# Check the plugin got the workspace
assert_true(plugin.workspace)
workspace = plugin.workspace
ui = self.workbench.get_plugin("enaml.workbench.ui")
ui.show_window()
process_app_events()
workspace.create_debugger("debugger_false")
process_app_events()
assert_false(plugin.debugger_instances)
def test_closing_debugger_panel(self):
""" Test closing a debugger panel and reopening one.
"""
plugin = self.workbench.get_plugin(u"hqc_meas.debug")
core = self.workbench.get_plugin(u"enaml.workbench.core")
cmd = u"enaml.workbench.ui.select_workspace"
core.invoke_command(cmd, {"workspace": u"hqc_meas.debug.workspace"}, self)
# Check the plugin got the workspace
assert_true(plugin.workspace)
workspace = plugin.workspace
ui = self.workbench.get_plugin("enaml.workbench.ui")
ui.show_window()
process_app_events()
workspace.create_debugger("debugger1")
process_app_events()
workspace.create_debugger("debugger1")
process_app_events()
workspace.create_debugger("debugger1")
process_app_events()
debugger = plugin.debugger_instances[1]
item = workspace.dock_area.find("item_2")
item.proxy.widget.close()
process_app_events()
item.destroy()
process_app_events()
assert_equal(len(workspace.dock_area.dock_items()), 3)
assert_equal(len(plugin.debugger_instances), 2)
assert_true(debugger.released)
workspace.create_debugger("debugger1")
process_app_events()
assert_equal(len(plugin.debugger_instances), 3)
assert_true(workspace.dock_area.find("item_2"))
class TestPreferencesPlugin(object):
"""Test the preferences plugin capabilities.
"""
def setup(self):
self.workbench = Workbench()
self.workbench.register(CoreManifest())
self.workbench.register(AppManifest())
self.workbench.register(ErrorsManifest())
@pytest.mark.ui
def test_app_startup1(self, tmpdir, windows):
"""Test app start-up when no app_directory.ini exists.
"""
manifest = PreferencesManifest()
self.workbench.register(manifest)
# Remove any trash app_directory.ini file. The global fixture ensure
# that it cannot be a user file.
app_pref = os.path.join(ecpy_path(), APP_PREFERENCES, APP_DIR_CONFIG)
if os.path.isfile(app_pref):
os.remove(app_pref)
# Start the app and fake a user answer.
app = self.workbench.get_plugin('ecpy.app')
app_dir = str(tmpdir.join('ecpy'))
with handle_dialog(custom=lambda x: setattr(x, 'path', app_dir)):
app.run_app_startup(object())
assert os.path.isfile(app_pref)
assert ConfigObj(app_pref)['app_path'] == app_dir
assert os.path.isdir(app_dir)
@pytest.mark.ui
def test_app_startup2(self, tmpdir, windows):
"""Test app start-up when user quit app.
"""
manifest = PreferencesManifest()
self.workbench.register(manifest)
# Remove any trash app_directory.ini file. The global fixture ensure
# that it cannot be a user file.
app_pref = os.path.join(ecpy_path(), APP_PREFERENCES, APP_DIR_CONFIG)
if os.path.isfile(app_pref):
os.remove(app_pref)
# Start the app and fake a user answer.
app = self.workbench.get_plugin('ecpy.app')
with pytest.raises(SystemExit):
with handle_dialog('reject'):
app.run_app_startup(object())
def test_app_startup3(self, tmpdir, windows):
"""Test app start-up when a preference file already exists.
"""
manifest = PreferencesManifest()
self.workbench.register(manifest)
# Create a trash app_directory.ini file. The global fixture ensure
# that it cannot be a user file. Don't use app_dir fixture as I need to
# test directory creation.
app_pref = os.path.join(ecpy_path(), APP_PREFERENCES, APP_DIR_CONFIG)
app_dir = str(tmpdir.join('ecpy'))
conf = ConfigObj()
conf.filename = app_pref
conf['app_path'] = app_dir
conf.write()
assert not os.path.isdir(app_dir)
# Start the app and fake a user answer.
app = self.workbench.get_plugin('ecpy.app')
app.run_app_startup(object())
assert os.path.isdir(app_dir)
def test_app_startup4(self, tmpdir, windows):
"""Test app start-up when user request to reset app folder.
"""
manifest = PreferencesManifest()
self.workbench.register(manifest)
app_dir = str(tmpdir.join('ecpy'))
# Add a app_directory.ini file.
app_pref = os.path.join(ecpy_path(), APP_PREFERENCES, APP_DIR_CONFIG)
if not os.path.isfile(app_pref):
conf = ConfigObj()
conf.filename = app_pref
conf['app_path'] = app_dir
conf.write()
# Start the app and fake a user answer.
app = self.workbench.get_plugin('ecpy.app')
class DummyArgs(object):
reset_app_folder = True
with handle_dialog(custom=lambda x: setattr(x, 'path', app_dir)):
app.run_app_startup(DummyArgs)
assert os.path.isfile(app_pref)
assert ConfigObj(app_pref)['app_path'] == app_dir
assert os.path.isdir(app_dir)
def test_lifecycle(self, app_dir):
"""Test the plugin lifecycle when no default.ini exist in app folder.
"""
pref_man = PreferencesManifest()
self.workbench.register(pref_man)
c_man = PrefContributor()
self.workbench.register(c_man)
# Start preferences plugin.
prefs = self.workbench.get_plugin(PLUGIN_ID)
assert prefs.app_directory == app_dir
assert os.path.isdir(os.path.join(app_dir, 'prefs'))
core = self.workbench.get_plugin('enaml.workbench.core')
assert core.invoke_command('ecpy.app.preferences.get',
dict(plugin_id='test.prefs')) is not None
self.workbench.register(PrefContributor2())
assert core.invoke_command('ecpy.app.preferences.get',
dict(plugin_id='test.prefs2')) is not None
# Stopping
self.workbench.unregister(c_man.id)
with pytest.raises(KeyError):
core.invoke_command('ecpy.app.preferences.get',
dict(plugin_id='test.prefs'))
self.workbench.unregister(pref_man.id)
assert not prefs._prefs
assert not prefs._pref_decls
def test_load_defaultini(self, app_dir):
"""Test that a default.ini file found in the app folder under prefs
is loaded on startup.
"""
prefs_path = os.path.join(app_dir, 'prefs')
os.mkdir(os.path.join(app_dir, 'prefs'))
conf = ConfigObj(os.path.join(prefs_path, 'default.ini'))
c_man = PrefContributor()
conf[c_man.id] = {}
conf[c_man.id]['string'] = 'This is a test'
conf.write()
pref_man = PreferencesManifest()
self.workbench.register(pref_man)
self.workbench.register(c_man)
c_pl = self.workbench.get_plugin(c_man.id)
assert c_pl.string == 'This is a test'
def test_update_contrib_and_type_checking(self, app_dir):
"""Check that the contributions are correctly updated when a new
plugin is registered and check that the contribution is of the right
type.
"""
pref_man = PreferencesManifest()
self.workbench.register(pref_man)
c_man = PrefContributor()
self.workbench.register(c_man)
# Start preferences plugin.
self.workbench.get_plugin(PLUGIN_ID)
# Test observation of extension point and type checking.
b_man = BadPrefContributor()
with pytest.raises(TypeError):
self.workbench.register(b_man)
def test_auto_sync(self, app_dir):
"""Check that auito_sync members are correctly handled.
"""
self.workbench.register(PreferencesManifest())
c_man = PrefContributor()
self.workbench.register(c_man)
contrib = self.workbench.get_plugin(c_man.id)
contrib.auto = 'test_auto'
ref = {c_man.id: {'auto': 'test_auto'}}
path = os.path.join(app_dir, 'prefs', 'default.ini')
assert os.path.isfile(path)
assert ConfigObj(path).dict() == ref
contrib.auto = 'test'
ref = {c_man.id: {'auto': 'test'}}
path = os.path.join(app_dir, 'prefs', 'default.ini')
assert os.path.isfile(path)
assert ConfigObj(path).dict() == ref
def test_save1(self, app_dir):
"""Test saving to the default file.
"""
self.workbench.register(PreferencesManifest())
c_man = PrefContributor()
self.workbench.register(c_man)
contrib = self.workbench.get_plugin(c_man.id)
contrib.string = 'test_save'
core = self.workbench.get_plugin('enaml.workbench.core')
core.invoke_command('ecpy.app.preferences.save', {}, self)
path = os.path.join(app_dir, 'prefs', 'default.ini')
ref = {c_man.id: {'string': 'test_save', 'auto': ''}}
assert os.path.isfile(path)
assert ConfigObj(path).dict() == ref
def test_save2(self, app_dir):
"""Test saving to a specific file.
"""
self.workbench.register(PreferencesManifest())
c_man = PrefContributor()
self.workbench.register(c_man)
contrib = self.workbench.get_plugin(c_man.id)
contrib.string = 'test_save'
path = os.path.join(app_dir, 'prefs', 'custom.ini')
core = self.workbench.get_plugin('enaml.workbench.core')
core.invoke_command('ecpy.app.preferences.save', {'path': path})
ref = {c_man.id: {'string': 'test_save', 'auto': ''}}
assert os.path.isfile(path)
assert ConfigObj(path).dict() == ref
def test_save3(self, app_dir, monkeypatch):
"""Test saving to a specific file.
"""
self.workbench.register(PreferencesManifest())
c_man = PrefContributor()
self.workbench.register(c_man)
contrib = self.workbench.get_plugin(c_man.id)
contrib.string = 'test_save'
prefs_path = os.path.join(app_dir, 'prefs')
path = os.path.join(prefs_path, 'custom.ini')
@classmethod
def answer(*args, **kwargs):
return path
with enaml.imports():
from ecpy.app.preferences.manifest import FileDialogEx
monkeypatch.setattr(FileDialogEx, 'get_save_file_name', answer)
core = self.workbench.get_plugin('enaml.workbench.core')
core.invoke_command('ecpy.app.preferences.save', {
'path': prefs_path,
'ask_user': True
})
ref = {c_man.id: {'string': 'test_save', 'auto': ''}}
assert os.path.isfile(path)
assert ConfigObj(path).dict() == ref
assert self.workbench.get_plugin(PLUGIN_ID).last_directory == \
prefs_path
def test_load1(self, app_dir):
"""Test loading default preferences for unstarted plugin.
"""
# Register and start preferences plugin
self.workbench.register(PreferencesManifest())
self.workbench.get_plugin(PLUGIN_ID)
c_man = PrefContributor()
self.workbench.register(c_man)
path = os.path.join(app_dir, 'prefs', 'default.ini')
conf = ConfigObj(path)
conf[c_man.id] = {}
conf[c_man.id]['string'] = 'test'
conf.write()
core = self.workbench.get_plugin('enaml.workbench.core')
core.invoke_command('ecpy.app.preferences.load', {})
assert self.workbench.get_plugin(c_man.id, False) is None
contrib = self.workbench.get_plugin(c_man.id)
assert contrib.string == 'test'
def test_load2(self, app_dir):
"""Test loading preferences from non-existing file.
"""
self.workbench.register(PreferencesManifest())
self.workbench.register(PrefContributor())
core = self.workbench.get_plugin('enaml.workbench.core')
core.invoke_command('ecpy.app.preferences.load', {'path': ''}, self)
assert not self.workbench.get_plugin(PLUGIN_ID)._prefs
def test_load3(self, app_dir):
"""Test loading preferences from non-default file for started plugin.
"""
self.workbench.register(PreferencesManifest())
c_man = PrefContributor()
self.workbench.register(c_man)
contrib = self.workbench.get_plugin(c_man.id)
path = os.path.join(app_dir, 'prefs', 'custom.ini')
conf = ConfigObj(path)
conf[c_man.id] = {}
conf[c_man.id]['string'] = 'test'
conf.write()
assert contrib.string == ''
core = self.workbench.get_plugin('enaml.workbench.core')
core.invoke_command('ecpy.app.preferences.load', {'path': path}, self)
assert contrib.string == 'test'
def test_load4(self, app_dir, monkeypatch):
"""Test loading preferences from non-default file for started plugin.
"""
self.workbench.register(PreferencesManifest())
c_man = PrefContributor()
self.workbench.register(c_man)
contrib = self.workbench.get_plugin(c_man.id)
prefs_path = os.path.join(app_dir, 'prefs')
path = os.path.join(prefs_path, 'custom.ini')
conf = ConfigObj(path)
conf[c_man.id] = {}
conf[c_man.id]['string'] = 'test'
conf.write()
assert contrib.string == ''
@classmethod
def answer(*args, **kwargs):
return path
with enaml.imports():
from ecpy.app.preferences.manifest import FileDialogEx
monkeypatch.setattr(FileDialogEx, 'get_open_file_name', answer)
core = self.workbench.get_plugin('enaml.workbench.core')
core.invoke_command('ecpy.app.preferences.load', {
'path': prefs_path,
'ask_user': True
}, self)
assert contrib.string == 'test'
assert self.workbench.get_plugin(PLUGIN_ID).last_directory == \
prefs_path
class TestExtensionsCollector(object):
"""Test the ExtensionsCollector behaviour.
"""
def setup(self):
self.workbench = Workbench()
self.workbench.register(CoreManifest())
self.workbench.register(ErrorsManifest())
self.workbench.register(ExtensionManifest())
def test_registation1(self, windows):
"""Test that plugin registered before starting the plugin are well
detected
"""
c = Contributor1()
self.workbench.register(c)
plugin = self.workbench.get_plugin(PLUGIN_ID)
assert 'contrib1.contrib' in plugin.contribs.contributions
self.workbench.unregister(c.id)
assert 'contrib1.contrib' not in plugin.contribs.contributions
assert not plugin.contribs._extensions
plugin.contribs.stop()
assert not plugin.contribs.contributions
def test_registration2(self, windows):
"""Test contribs update when a new plugin is registered.
"""
self.workbench.register(Contributor2())
plugin = self.workbench.get_plugin(PLUGIN_ID)
c = Contributor1()
self.workbench.register(c)
assert 'contrib1.contrib' in plugin.contribs.contributions
self.workbench.unregister(c.id)
assert 'contrib1.contrib' not in plugin.contribs.contributions
def test_factory(self, windows):
"""Test getting the Contribution declaration from a factory.
"""
c = Contributor2()
self.workbench.register(c)
plugin = self.workbench.get_plugin(PLUGIN_ID)
assert 'contrib2.contrib' in plugin.contribs.contributions
self.workbench.unregister(c.id)
assert 'contrib2.contrib' not in plugin.contribs.contributions
@pytest.mark.ui
def test_errors1(self, windows):
"""Test uniqueness of contribution id.
"""
self.workbench.register(Contributor1())
self.workbench.register(Contributor1(id='bis'))
self.workbench.register(Contributor1(id='ter'))
with handle_dialog():
self.workbench.get_plugin(PLUGIN_ID)
@pytest.mark.ui
def test_check_errors2(self, windows):
"""Test use of validate_ext.
"""
self.workbench.register(Contributor3())
with handle_dialog():
self.workbench.get_plugin(PLUGIN_ID)
def test_check_errors3(self, windows):
"""Test enforcement of type when using factory.
"""
self.workbench.register(Contributor4())
with handle_dialog():
self.workbench.get_plugin(PLUGIN_ID)
def test_declared_by(self):
"""Test getting the extension declaring a particular contribution.
"""
c = Contributor1()
self.workbench.register(c)
plugin = self.workbench.get_plugin(PLUGIN_ID)
assert plugin.contribs.contributed_by('contrib1.contrib') is \
c.extensions[0]
class TestPluginCoreFunctionalities(object):
test_dir = ''
@classmethod
def setup_class(cls):
print complete_line(
__name__ + ':{}.setup_class()'.format(cls.__name__), '-', 77)
# Creating dummy directory for prefs (avoid prefs interferences).
directory = os.path.dirname(__file__)
cls.test_dir = os.path.join(directory, '_temps')
create_test_dir(cls.test_dir)
# Creating dummy default.ini file in utils.
util_path = os.path.join(directory, '..', '..', 'hqc_meas', 'utils',
'preferences')
def_path = os.path.join(util_path, 'default.ini')
# Making the preference manager look for info in test dir.
default = ConfigObj(def_path)
default['folder'] = cls.test_dir
default['file'] = 'default_test.ini'
default.write()
conf = ConfigObj(os.path.join(cls.test_dir, 'default_test.ini'))
conf[u'hqc_meas.debug'] = {}
conf.write()
@classmethod
def teardown_class(cls):
print complete_line(
__name__ + ':{}.teardown_class()'.format(cls.__name__), '-', 77)
# Removing pref files creating during tests.
remove_tree(cls.test_dir)
# Restoring default.ini file in utils
directory = os.path.dirname(__file__)
util_path = os.path.join(directory, '..', '..', 'hqc_meas', 'utils',
'preferences')
def_path = os.path.join(util_path, 'default.ini')
os.remove(def_path)
def setup(self):
self.workbench = Workbench()
self.workbench.register(CoreManifest())
self.workbench.register(StateManifest())
self.workbench.register(PreferencesManifest())
def teardown(self):
self.workbench.unregister(u'hqc_meas.debug')
self.workbench.unregister(u'hqc_meas.preferences')
self.workbench.unregister(u'hqc_meas.state')
self.workbench.unregister(u'enaml.workbench.core')
def test_init(self):
""" Test automatic registration at init.
"""
# Tamper with prefs to alter startup.
pref_plugin = self.workbench.get_plugin(u'hqc_meas.preferences')
prefs = {
'manifests':
repr([('tests.debug.dummies', 'DummyDebugger1'),
('tests.debug.dummies', 'NonExistent')])
}
pref_plugin._prefs[u'hqc_meas.debug'].update(prefs)
self.workbench.register(DebuggerManifest())
plugin = self.workbench.get_plugin(u'hqc_meas.debug')
pref_plugin._prefs[u'hqc_meas.debug'] = {}
assert_in(u'dummy.debugger1', plugin._manifest_ids)
assert_in(u'dummy.debugger1', plugin.debuggers)
# Automatically registered plugins are automatically unregistered.
#--- Debuggers tests ------------------------------------------------------
def test_check_registation1(self):
""" Test that debuggers are properly found at start-up.
"""
self.workbench.register(DebuggerManifest())
self.workbench.register(DummyDebugger1())
plugin = self.workbench.get_plugin(u'hqc_meas.debug')
assert_in(u'dummy.debugger1', plugin.debuggers)
assert_true(plugin._debugger_extensions)
self.workbench.unregister(u'dummy.debugger1')
assert_not_in(u'dummy.debugger1', plugin.debuggers)
assert_false(plugin._debugger_extensions)
def test_check_registration2(self):
""" Test debuggers update when a new plugin is registered.
"""
self.workbench.register(DebuggerManifest())
plugin = self.workbench.get_plugin(u'hqc_meas.debug')
self.workbench.register(DummyDebugger1())
assert_in(u'dummy.debugger1', plugin.debuggers)
# Increase coverage by checking we reuse known extensions.
self.workbench.register(DummyDebugger1ter())
assert_in(u'dummy.debugger1ter', plugin.debuggers)
self.workbench.unregister(u'dummy.debugger1')
assert_not_in(u'dummy.debugger1', plugin.debuggers)
self.workbench.unregister(u'dummy.debugger1ter')
assert_not_in(u'dummy.debugger1ter', plugin.debuggers)
def test_check_factory(self):
""" Test getting the Debugger decl from a factory.
"""
self.workbench.register(DebuggerManifest())
self.workbench.register(DummyDebugger3())
plugin = self.workbench.get_plugin(u'hqc_meas.debug')
assert_in(u'dummy.debugger3', plugin.debuggers)
self.workbench.unregister(u'dummy.debugger3')
assert_not_in(u'dummy.debugger3', plugin.debuggers)
@raises(ValueError)
def test_check_errors1(self):
""" Test uniqueness of Debugger id.
"""
self.workbench.register(DebuggerManifest())
self.workbench.get_plugin(u'hqc_meas.debug')
self.workbench.register(DummyDebugger1())
self.workbench.register(DummyDebugger1bis())
@raises(ValueError)
def test_check_errors2(self):
""" Test presence of factory in Debugger.
"""
self.workbench.register(DebuggerManifest())
self.workbench.register(DummyDebugger2())
self.workbench.get_plugin(u'hqc_meas.debug')
@raises(ValueError)
def test_check_errors2bis(self):
""" Test presence of view in Debugger.
"""
self.workbench.register(DebuggerManifest())
self.workbench.register(DummyDebugger2bis())
self.workbench.get_plugin(u'hqc_meas.debug')
@raises(TypeError)
def test_check_errors3(self):
""" Test enforcement of type for Debugger when using factory.
"""
self.workbench.register(DebuggerManifest())
self.workbench.register(DummyDebugger4())
self.workbench.get_plugin(u'hqc_meas.debug')
def setup(self):
self.workbench = Workbench()
self.workbench.register(CoreManifest())
self.workbench.register(StateManifest())
self.workbench.register(StateContributor())
def instr_workbench(monkeypatch, app_dir, app):
"""Setup the workbench in such a way that the instrs manager can be tested.
"""
def exit_err(self):
if self._delayed:
raise Exception('Unexpected exceptions occured :\n' +
pformat(self._delayed))
monkeypatch.setattr(ErrorsPlugin, 'exit_error_gathering', exit_err)
workbench = Workbench()
workbench.register(CoreManifest())
workbench.register(AppManifest())
workbench.register(PreferencesManifest())
workbench.register(ErrorsManifest())
workbench.register(StateManifest())
workbench.register(DependenciesManifest())
workbench.register(InstrumentManagerManifest())
yield workbench
for m_id in ('ecpy.instruments', 'ecpy.app.dependencies',
'ecpy.app.errors', 'ecpy.app.preferences',
'ecpy.app.states', 'ecpy.app'):
try:
workbench.unregister(m_id)
except Exception:
pass
def setup(self):
self.workbench = Workbench()
self.workbench.register(CoreManifest())
self.workbench.register(AppManifest())
self.workbench.register(ErrorsManifest())
def setup(self):
self.workbench = Workbench()
self.workbench.register(CoreManifest())
self.workbench.register(ErrorsManifest())
self.workbench.register(DeclaratorManifest())
class TestLoopView(object):
def setup(self):
self.workbench = Workbench()
self.workbench.register(CoreManifest())
self.workbench.register(StateManifest())
self.workbench.register(PreferencesManifest())
self.workbench.register(TaskManagerManifest())
self.root = RootTask(should_stop=Event(), should_pause=Event())
self.task = LoopTask(task_name='Test')
self.root.children_task.append(self.task)
def teardown(self):
close_all_windows()
self.workbench.unregister(u'hqc_meas.task_manager')
self.workbench.unregister(u'hqc_meas.preferences')
self.workbench.unregister(u'hqc_meas.state')
self.workbench.unregister(u'enaml.workbench.core')
def test_view1(self):
# Intantiate a view with no selected interface and select one after
window = enaml.widgets.api.Window()
core = self.workbench.get_plugin('enaml.workbench.core')
view = LoopView(window, task=self.task, core=core)
window.show()
process_app_events()
view.widgets()[1].selected = LinspaceLoopInterface
process_app_events()
assert_is_instance(self.task.interface, LinspaceLoopInterface)
view.widgets()[1].selected = IterableLoopInterface
process_app_events()
assert_is_instance(self.task.interface, IterableLoopInterface)
def test_view2(self):
# Intantiate a view with a selected interface.
interface = LinspaceLoopInterface()
self.task.interface = interface
window = enaml.widgets.api.Window()
core = self.workbench.get_plugin('enaml.workbench.core')
LoopView(window, task=self.task, core=core)
window.show()
process_app_events()
assert_is(self.task.interface, interface)
class TestState(object):
"""Test the handling os states by the state plugin.
"""
def setup(self):
self.workbench = Workbench()
self.workbench.register(CoreManifest())
self.workbench.register(StateManifest())
self.workbench.register(StateContributor())
def test_get_state(self):
"""Test accessing to a state object through the command.
"""
core = self.workbench.get_plugin(CORE_PLUGIN)
par = {'state_id': STATE_ID}
state = core.invoke_command(GET_STATE, par, trigger=self)
assert hasattr(state, 'string')
assert state.string == 'init'
with raises(AttributeError):
state.string = 1
self.workbench.unregister('exopy.app.states')
def test_state_unicity(self):
"""Test that asking twice the same state return the same object.
"""
core = self.workbench.get_plugin(CORE_PLUGIN)
par = {'state_id': STATE_ID}
state1 = core.invoke_command(GET_STATE, par, trigger=self)
state2 = core.invoke_command(GET_STATE, par, trigger=self)
assert state1 is state2
def test_member_sync(self):
"""Test that the state is correctly synchronised with the plugin.
"""
core = self.workbench.get_plugin(CORE_PLUGIN)
par = {'state_id': STATE_ID}
state = core.invoke_command(GET_STATE, par, trigger=self)
plugin = self.workbench.get_plugin('test.states')
plugin.string = 'test'
assert state.string == 'test'
def test_death_notif(self):
"""Test that a state whose plugin is unregistered is marked as dead.
"""
core = self.workbench.get_plugin(CORE_PLUGIN)
par = {'state_id': STATE_ID}
state = core.invoke_command(GET_STATE, par, trigger=self)
self.workbench.unregister(u'test.states')
assert not state.alive
from enaml.workbench.api import Workbench
if __name__ == '__main__':
with enaml.imports():
from enaml.workbench.core.core_manifest import CoreManifest
from enaml.workbench.ui.ui_manifest import UIManifest
from psi.setting.manifest import SettingManifest
from psi.data.manifest import DataManifest
from psi.controller.manifest import ControllerManifest
from psi.experiment.manifest import ExperimentManifest
with warnings.catch_warnings():
warnings.simplefilter('ignore')
workbench = Workbench()
workbench.register(CoreManifest())
workbench.register(UIManifest())
workbench.register(SettingManifest())
workbench.register(DataManifest())
workbench.register(ControllerManifest())
workbench.register(ExperimentManifest())
core = workbench.get_plugin('enaml.workbench.core')
ui = workbench.get_plugin('enaml.workbench.ui')
parameters = core.invoke_command('psi.setting.get_parameters')
parameters[0].rove = True
name = parameters[0].name
class TestPreferencesPlugin(object):
"""Test the preferences plugin capabilities.
"""
def setup(self):
self.workbench = Workbench()
self.workbench.register(CoreManifest())
self.workbench.register(AppManifest())
self.workbench.register(ErrorsManifest())
@pytest.mark.ui
def test_app_startup1(self, tmpdir, windows):
"""Test app start-up when no app_directory.ini exists.
"""
manifest = PreferencesManifest()
self.workbench.register(manifest)
# Remove any trash app_directory.ini file. The global fixture ensure
# that it cannot be a user file.
app_pref = os.path.join(ecpy_path(), APP_PREFERENCES, APP_DIR_CONFIG)
if os.path.isfile(app_pref):
os.remove(app_pref)
# Start the app and fake a user answer.
app = self.workbench.get_plugin('ecpy.app')
app_dir = str(tmpdir.join('ecpy'))
with handle_dialog(custom=lambda x: setattr(x, 'path', app_dir)):
app.run_app_startup(object())
assert os.path.isfile(app_pref)
assert ConfigObj(app_pref)['app_path'] == app_dir
assert os.path.isdir(app_dir)
@pytest.mark.ui
def test_app_startup2(self, tmpdir, windows):
"""Test app start-up when user quit app.
"""
manifest = PreferencesManifest()
self.workbench.register(manifest)
# Remove any trash app_directory.ini file. The global fixture ensure
# that it cannot be a user file.
app_pref = os.path.join(ecpy_path(), APP_PREFERENCES, APP_DIR_CONFIG)
if os.path.isfile(app_pref):
os.remove(app_pref)
# Start the app and fake a user answer.
app = self.workbench.get_plugin('ecpy.app')
with pytest.raises(SystemExit):
with handle_dialog('reject'):
app.run_app_startup(object())
def test_app_startup3(self, tmpdir, windows):
"""Test app start-up when a preference file already exists.
"""
manifest = PreferencesManifest()
self.workbench.register(manifest)
# Create a trash app_directory.ini file. The global fixture ensure
# that it cannot be a user file. Don't use app_dir fixture as I need to
# test directory creation.
app_pref = os.path.join(ecpy_path(), APP_PREFERENCES, APP_DIR_CONFIG)
app_dir = str(tmpdir.join('ecpy'))
conf = ConfigObj()
conf.filename = app_pref
conf['app_path'] = app_dir
conf.write()
assert not os.path.isdir(app_dir)
# Start the app and fake a user answer.
app = self.workbench.get_plugin('ecpy.app')
app.run_app_startup(object())
assert os.path.isdir(app_dir)
def test_app_startup4(self, tmpdir, windows):
"""Test app start-up when user request to reset app folder.
"""
manifest = PreferencesManifest()
self.workbench.register(manifest)
app_dir = str(tmpdir.join('ecpy'))
# Add a app_directory.ini file.
app_pref = os.path.join(ecpy_path(), APP_PREFERENCES, APP_DIR_CONFIG)
if not os.path.isfile(app_pref):
conf = ConfigObj()
conf.filename = app_pref
conf['app_path'] = app_dir
conf.write()
# Start the app and fake a user answer.
app = self.workbench.get_plugin('ecpy.app')
class DummyArgs(object):
reset_app_folder = True
with handle_dialog(custom=lambda x: setattr(x, 'path', app_dir)):
app.run_app_startup(DummyArgs)
assert os.path.isfile(app_pref)
assert ConfigObj(app_pref)['app_path'] == app_dir
assert os.path.isdir(app_dir)
def test_lifecycle(self, app_dir):
"""Test the plugin lifecycle when no default.ini exist in app folder.
"""
pref_man = PreferencesManifest()
self.workbench.register(pref_man)
c_man = PrefContributor()
self.workbench.register(c_man)
# Start preferences plugin.
prefs = self.workbench.get_plugin(PLUGIN_ID)
assert prefs.app_directory == app_dir
assert os.path.isdir(os.path.join(app_dir, 'preferences'))
core = self.workbench.get_plugin('enaml.workbench.core')
assert core.invoke_command('ecpy.app.preferences.get',
dict(plugin_id='test.prefs')) is not None
self.workbench.register(PrefContributor2())
assert core.invoke_command('ecpy.app.preferences.get',
dict(plugin_id='test.prefs2')) is not None
# Stopping
self.workbench.unregister(c_man.id)
with pytest.raises(KeyError):
core.invoke_command('ecpy.app.preferences.get',
dict(plugin_id='test.prefs'))
self.workbench.unregister(pref_man.id)
assert not prefs._prefs
assert not prefs._pref_decls
def test_load_defaultini(self, app_dir):
"""Test that a default.ini file found in the app folder under prefs
is loaded on startup.
"""
prefs_path = os.path.join(app_dir, 'preferences')
os.mkdir(os.path.join(app_dir, 'preferences'))
conf = ConfigObj(os.path.join(prefs_path, 'default.ini'))
c_man = PrefContributor()
conf[c_man.id] = {}
conf[c_man.id]['string'] = 'This is a test'
conf.write()
pref_man = PreferencesManifest()
self.workbench.register(pref_man)
self.workbench.register(c_man)
c_pl = self.workbench.get_plugin(c_man.id)
assert c_pl.string == 'This is a test'
def test_update_contrib_and_type_checking(self, app_dir):
"""Check that the contributions are correctly updated when a new
plugin is registered and check that the contribution is of the right
type.
"""
pref_man = PreferencesManifest()
self.workbench.register(pref_man)
c_man = PrefContributor()
self.workbench.register(c_man)
# Start preferences plugin.
self.workbench.get_plugin(PLUGIN_ID)
# Test observation of extension point and type checking.
b_man = BadPrefContributor()
with pytest.raises(TypeError):
self.workbench.register(b_man)
def test_auto_sync(self, app_dir):
"""Check that auito_sync members are correctly handled.
"""
self.workbench.register(PreferencesManifest())
c_man = PrefContributor()
self.workbench.register(c_man)
contrib = self.workbench.get_plugin(c_man.id)
contrib.auto = 'test_auto'
ref = {c_man.id: {'auto': 'test_auto'}}
path = os.path.join(app_dir, 'preferences', 'default.ini')
assert os.path.isfile(path)
assert ConfigObj(path).dict() == ref
contrib.auto = 'test'
ref = {c_man.id: {'auto': 'test'}}
path = os.path.join(app_dir, 'preferences', 'default.ini')
assert os.path.isfile(path)
assert ConfigObj(path).dict() == ref
def test_save1(self, app_dir):
"""Test saving to the default file.
"""
self.workbench.register(PreferencesManifest())
c_man = PrefContributor()
self.workbench.register(c_man)
contrib = self.workbench.get_plugin(c_man.id)
contrib.string = 'test_save'
core = self.workbench.get_plugin('enaml.workbench.core')
core.invoke_command('ecpy.app.preferences.save', {}, self)
path = os.path.join(app_dir, 'preferences', 'default.ini')
ref = {c_man.id: {'string': 'test_save', 'auto': ''}}
assert os.path.isfile(path)
assert ConfigObj(path).dict() == ref
def test_save2(self, app_dir):
"""Test saving to a specific file.
"""
self.workbench.register(PreferencesManifest())
c_man = PrefContributor()
self.workbench.register(c_man)
contrib = self.workbench.get_plugin(c_man.id)
contrib.string = 'test_save'
path = os.path.join(app_dir, 'preferences', 'custom.ini')
core = self.workbench.get_plugin('enaml.workbench.core')
core.invoke_command('ecpy.app.preferences.save', {'path': path})
ref = {c_man.id: {'string': 'test_save', 'auto': ''}}
assert os.path.isfile(path)
assert ConfigObj(path).dict() == ref
def test_save3(self, app_dir, monkeypatch):
"""Test saving to a specific file.
"""
self.workbench.register(PreferencesManifest())
c_man = PrefContributor()
self.workbench.register(c_man)
contrib = self.workbench.get_plugin(c_man.id)
contrib.string = 'test_save'
prefs_path = os.path.join(app_dir, 'preferences')
path = os.path.join(prefs_path, 'custom.ini')
@classmethod
def answer(*args, **kwargs):
return path
with enaml.imports():
from ecpy.app.preferences.manifest import FileDialogEx
monkeypatch.setattr(FileDialogEx, 'get_save_file_name', answer)
core = self.workbench.get_plugin('enaml.workbench.core')
core.invoke_command('ecpy.app.preferences.save', {'path': prefs_path,
'ask_user': True})
ref = {c_man.id: {'string': 'test_save', 'auto': ''}}
assert os.path.isfile(path)
assert ConfigObj(path).dict() == ref
assert self.workbench.get_plugin(PLUGIN_ID).last_directory == \
prefs_path
def test_load1(self, app_dir):
"""Test loading default preferences for unstarted plugin.
"""
# Register and start preferences plugin
self.workbench.register(PreferencesManifest())
self.workbench.get_plugin(PLUGIN_ID)
c_man = PrefContributor()
self.workbench.register(c_man)
path = os.path.join(app_dir, 'preferences', 'default.ini')
conf = ConfigObj(path)
conf[c_man.id] = {}
conf[c_man.id]['string'] = 'test'
conf.write()
core = self.workbench.get_plugin('enaml.workbench.core')
core.invoke_command('ecpy.app.preferences.load', {})
assert self.workbench.get_plugin(c_man.id, False) is None
contrib = self.workbench.get_plugin(c_man.id)
assert contrib.string == 'test'
def test_load2(self, app_dir):
"""Test loading preferences from non-existing file.
"""
self.workbench.register(PreferencesManifest())
self.workbench.register(PrefContributor())
core = self.workbench.get_plugin('enaml.workbench.core')
core.invoke_command('ecpy.app.preferences.load',
{'path': ''}, self)
assert not self.workbench.get_plugin(PLUGIN_ID)._prefs
def test_load3(self, app_dir):
"""Test loading preferences from non-default file for started plugin.
"""
self.workbench.register(PreferencesManifest())
c_man = PrefContributor()
self.workbench.register(c_man)
contrib = self.workbench.get_plugin(c_man.id)
path = os.path.join(app_dir, 'preferences', 'custom.ini')
conf = ConfigObj(path)
conf[c_man.id] = {}
conf[c_man.id]['string'] = 'test'
conf.write()
assert contrib.string == ''
core = self.workbench.get_plugin('enaml.workbench.core')
core.invoke_command('ecpy.app.preferences.load',
{'path': path}, self)
assert contrib.string == 'test'
def test_load4(self, app_dir, monkeypatch):
"""Test loading preferences from non-default file for started plugin.
"""
self.workbench.register(PreferencesManifest())
c_man = PrefContributor()
self.workbench.register(c_man)
contrib = self.workbench.get_plugin(c_man.id)
prefs_path = os.path.join(app_dir, 'preferences')
path = os.path.join(prefs_path, 'custom.ini')
conf = ConfigObj(path)
conf[c_man.id] = {}
conf[c_man.id]['string'] = 'test'
conf.write()
assert contrib.string == ''
@classmethod
def answer(*args, **kwargs):
return path
with enaml.imports():
from ecpy.app.preferences.manifest import FileDialogEx
monkeypatch.setattr(FileDialogEx, 'get_open_file_name', answer)
core = self.workbench.get_plugin('enaml.workbench.core')
core.invoke_command('ecpy.app.preferences.load',
{'path': prefs_path, 'ask_user': True}, self)
assert contrib.string == 'test'
assert self.workbench.get_plugin(PLUGIN_ID).last_directory == \
prefs_path
class TestAppPlugin(object):
"""Test the AppPlugin capabilities.
"""
def setup(self):
self.workbench = Workbench()
self.workbench.register(AppManifest())
self.workbench.register(CoreManifest())
self.workbench.register(ErrorsManifest())
def test_app_start_up(self):
"""Test running startups leading to new startup registrations.
"""
manifest = StartupContributor()
self.workbench.register(manifest)
plugin = self.workbench.get_plugin('ecpy.app')
plugin.run_app_startup(object())
assert manifest.called == [
'test_nested.startup1', 'test.startup2', 'test_nested.startup2'
]
self.workbench.unregister('ecpy.app')
def test_closing(self):
"""Test that validation stops as soon as the event is rejected.
"""
manifest1 = ClosingContributor1()
manifest2 = ClosingContributor2()
self.workbench.register(manifest1)
self.workbench.register(manifest2)
window = FalseWindow(self.workbench)
plugin = self.workbench.get_plugin('ecpy.app')
ev = CloseEvent()
plugin.validate_closing(window, ev)
assert not ev.is_accepted()
assert not manifest2.called or not manifest1.called
manifest1.accept = True
manifest2.accept = True
plugin.validate_closing(window, ev)
assert ev.is_accepted()
assert manifest2.called
def test_app_cleanup(self):
"""Test running the app cleanup.
"""
manifest = ClosedContributor()
self.workbench.register(manifest)
plugin = self.workbench.get_plugin('ecpy.app')
plugin.run_app_cleanup()
assert manifest.called == [
'test_nested.closed1', 'test.closed2', 'test_nested.closed2'
]
def test_app_startup_registation(self):
"""Test the AppStartup discovery.
"""
manifest = StartupContributor()
self.workbench.register(manifest)
plugin = self.workbench.get_plugin('ecpy.app')
assert len(plugin.startup.contributions) == 2
assert len(plugin._start_heap) == 2
self.workbench.unregister(manifest.id)
assert not plugin.startup.contributions
assert len(plugin._start_heap) == 0
def test_app_closing_registation(self):
"""Test the AppClosing discovery.
"""
manifest = ClosingContributor1()
self.workbench.register(manifest)
plugin = self.workbench.get_plugin('ecpy.app')
assert len(plugin.closing.contributions) == 1
self.workbench.unregister(manifest.id)
assert not plugin.closing.contributions
def test_app_closed_registation(self):
"""Test the AppClosed discovery.
"""
manifest = ClosedContributor()
self.workbench.register(manifest)
plugin = self.workbench.get_plugin('ecpy.app')
assert len(plugin.closed.contributions) == 2
assert len(plugin._clean_heap) == 2
self.workbench.unregister(manifest.id)
assert not plugin.closed.contributions
assert len(plugin._clean_heap) == 0
class TestSaveArrayView(object):
def setup(self):
self.workbench = Workbench()
self.workbench.register(CoreManifest())
self.workbench.register(StateManifest())
self.workbench.register(PreferencesManifest())
self.workbench.register(TaskManagerManifest())
self.root = RootTask(should_stop=Event(), should_pause=Event())
self.task = SaveArrayTask(task_name='Test')
self.root.children_task.append(self.task)
def teardown(self):
close_all_windows()
self.workbench.unregister(u'hqc_meas.task_manager')
self.workbench.unregister(u'hqc_meas.preferences')
self.workbench.unregister(u'hqc_meas.state')
self.workbench.unregister(u'enaml.workbench.core')
def test_view(self):
# Intantiate a view with no selected interface and select one after
window = enaml.widgets.api.Window()
view = SaveArrayView(window, task=self.task)
window.show()
process_app_events()
def setup(self):
self.workbench = Workbench()
self.workbench.register(AppManifest())
self.workbench.register(CoreManifest())
self.workbench.register(ErrorsManifest())
class TestPluginCoreFunctionalities(object):
test_dir = ''
@classmethod
def setup_class(cls):
print complete_line(
__name__ + ':{}.setup_class()'.format(cls.__name__), '-', 77)
# Creating dummy directory for prefs (avoid prefs interferences).
directory = os.path.dirname(__file__)
cls.test_dir = os.path.join(directory, '_temps')
create_test_dir(cls.test_dir)
# Creating dummy default.ini file in utils.
util_path = os.path.join(directory, '..', '..', 'hqc_meas', 'utils',
'preferences')
def_path = os.path.join(util_path, 'default.ini')
# Making the preference manager look for info in test dir.
default = ConfigObj(def_path)
default['folder'] = cls.test_dir
default['file'] = 'default_test.ini'
default.write()
conf = ConfigObj(os.path.join(cls.test_dir, 'default_test.ini'))
conf[u'hqc_meas.measure'] = {}
conf.write()
@classmethod
def teardown_class(cls):
print complete_line(
__name__ + ':{}.teardown_class()'.format(cls.__name__), '-', 77)
# Removing pref files creating during tests.
remove_tree(cls.test_dir)
# Restoring default.ini file in utils
directory = os.path.dirname(__file__)
util_path = os.path.join(directory, '..', '..', 'hqc_meas', 'utils',
'preferences')
def_path = os.path.join(util_path, 'default.ini')
os.remove(def_path)
def setup(self):
self.workbench = Workbench()
self.workbench.register(CoreManifest())
self.workbench.register(StateManifest())
self.workbench.register(PreferencesManifest())
self.workbench.register(DependenciesManifest())
self.workbench.register(TaskManagerManifest())
self.workbench.register(MeasureManifest())
self.workbench.register(TestSuiteManifest())
def teardown(self):
try:
self.workbench.unregister(u'tests.suite')
except ValueError:
pass
self.workbench.unregister(u'hqc_meas.measure')
self.workbench.unregister(u'hqc_meas.task_manager')
self.workbench.unregister(u'hqc_meas.dependencies')
self.workbench.unregister(u'hqc_meas.preferences')
self.workbench.unregister(u'hqc_meas.state')
self.workbench.unregister(u'enaml.workbench.core')
def test_save_load_measure1(self):
""" Test saving a measure to a file and reloading it.
"""
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
measure = Measure(plugin=plugin, name='Test', status='Under test')
measure.root_task = RootTask(default_path=self.test_dir)
# Needed because of Atom returning a _DictProxy
measure.checks = dict(plugin.checks)
# Needed because of Atom returning a _DictProxy
measure.headers = dict(plugin.headers)
# Adding a monitor.
monitor_decl = plugin.monitors[u'monitor1']
measure.add_monitor(monitor_decl.id,
monitor_decl.factory(monitor_decl, self.workbench))
measure.monitors[u'monitor1'].save_test = True
path = os.path.join(self.test_dir, 'saved_measure.ini')
# Save measure.
measure.save_measure(path)
assert_true(os.path.isfile(path))
# Load measure.
loaded = Measure.load_measure(plugin, path)
assert_equal(loaded.name, 'Test')
assert_equal(loaded.root_task.default_path, self.test_dir)
assert_equal(loaded.checks, dict(plugin.checks))
assert_equal(loaded.headers, dict(plugin.headers))
assert_in(u'monitor1', loaded.monitors)
monitor = loaded.monitors[u'monitor1']
assert_true(monitor.save_test)
# Check that all values have been correctly updated.
monitor = measure.monitors[u'monitor1']
assert_equal(monitor.measure_name, measure.name)
assert_equal(monitor.measure_status, measure.status)
assert_equal(monitor.updated, {'root/default_path': 1})
assert_equal(measure.collect_entries_to_observe(),
['root/default_path'])
# Check that the notifier is correctly observed.
assert_true(measure.root_task.task_database.has_observers('notifier'))
def test_save_load_measure2(self):
""" Test saving a measure to a file and reloading it with absent tools.
"""
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
measure = Measure(plugin=plugin, name='Test', status='Under test')
measure.root_task = RootTask(default_path=self.test_dir)
# Needed because of Atom returning a _DictProxy
measure.checks = dict(plugin.checks)
# Needed because of Atom returning a _DictProxy
measure.headers = dict(plugin.headers)
# Adding a monitor.
monitor_decl = plugin.monitors[u'monitor1']
measure.add_monitor(monitor_decl.id,
monitor_decl.factory(monitor_decl, self.workbench))
measure.monitors[u'monitor1'].save_test = True
path = os.path.join(self.test_dir, 'saved_measure.ini')
# Save measure.
measure.save_measure(path)
assert_true(os.path.isfile(path))
# Remove test_suite
self.workbench.unregister(u'tests.suite')
# Load measure.
loaded = Measure.load_measure(plugin, path)
assert_equal(loaded.name, 'Test')
assert_equal(loaded.root_task.default_path, self.test_dir)
assert_equal(loaded.checks, {})
assert_equal(loaded.headers, {})
assert_equal(loaded.monitors, {})
self.workbench.register(TestSuiteManifest())
def test_override_saved_measure(self):
""" Test that overriding a measure does override evrything.
"""
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
measure = Measure(plugin=plugin, name='Test', status='Under test')
measure.root_task = RootTask(default_path=self.test_dir)
# Needed because of Atom returning a _DictProxy
measure.checks = dict(plugin.checks)
# Needed because of Atom returning a _DictProxy
measure.headers = dict(plugin.headers)
# Adding a monitor.
monitor_decl = plugin.monitors[u'monitor1']
measure.add_monitor(monitor_decl.id,
monitor_decl.factory(monitor_decl, self.workbench))
measure.monitors[u'monitor1'].save_test = True
path = os.path.join(self.test_dir, 'saved_measure.ini')
# Save measure.
measure.save_measure(path)
# Create a new measure without headers and checks and test that the old
# values are not in the config file.
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
measure = Measure(plugin=plugin, name='Test', status='Under test')
measure.root_task = RootTask(default_path=self.test_dir)
measure.save_measure(path)
conf = ConfigObj(path)
assert_equal(conf['checks'], '[]')
assert_equal(conf['headers'], '[]')
def test_run_checks1(self):
""" Test running checks for a measure. Passing.
"""
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
measure = Measure(plugin=plugin)
measure.root_task = RootTask(default_path=self.test_dir)
# Needed because of Atom returning a _DictProxy
measure.checks = dict(plugin.checks)
Checker.test_pass = True
res, errors = measure.run_checks(self.workbench)
assert_true(res)
assert_equal(errors, {})
def test_run_checks2(self):
""" Test running checks for a measure. Failing because added check.
"""
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
measure = Measure(plugin=plugin)
measure.root_task = RootTask(default_path=self.test_dir)
# Needed because of Atom returning a _DictProxy
measure.checks = dict(plugin.checks)
Checker.test_pass = False
res, errors = measure.run_checks(self.workbench)
assert_false(res)
assert_equal(errors, {u'check1': {'test': 'Failed'}})
def test_run_checks3(self):
""" Test running checks for a measure. Failing because of RootTask.
"""
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
measure = Measure(plugin=plugin)
measure.root_task = RootTask()
# Needed because of Atom returning a _DictProxy
measure.checks = dict(plugin.checks)
Checker.test_pass = True
res, errors = measure.run_checks(self.workbench)
assert_false(res)
assert_in(u'internal', errors)
assert_not_in(u'check1', errors)
def test_run_checks4(self):
""" Test running checks for a measure. Passing without added.
"""
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
measure = Measure(plugin=plugin)
measure.root_task = RootTask()
measure.root_task = RootTask(default_path=self.test_dir)
# Needed because of Atom returning a _DictProxy
measure.checks = dict(plugin.checks)
Checker.test_pass = False
res, errors = measure.run_checks(self.workbench, internal_only=True)
assert_true(res)
assert_equal(errors, {})
def test_collect_headers(self):
""" Test header collection.
"""
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
measure = Measure(plugin=plugin)
measure.root_task = RootTask()
# Needed because of Atom returning a _DictProxy
measure.headers = dict(plugin.headers)
measure.collect_headers(self.workbench)
assert_equal(measure.root_task.default_header,
'Test header\nTest header')
def test_add_monitor1(self):
""" Test adding a new monitor.
"""
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
measure = Measure(plugin=plugin, name='Test', status='Under test')
measure.root_task = RootTask()
# Be sure that there is no observers for the database
assert_false(measure.root_task.task_database.has_observers('notifier'))
monitor_decl = plugin.monitors[u'monitor1']
measure.add_monitor(monitor_decl.id,
monitor_decl.factory(monitor_decl, self.workbench))
# Check the monitor is now in the list of the measure monitors
assert_in(u'monitor1', measure.monitors)
# Check that all values have been correctly updated.
monitor = measure.monitors[u'monitor1']
assert_equal(monitor.measure_name, measure.name)
assert_equal(monitor.measure_status, measure.status)
assert_equal(monitor.updated, {'root/default_path': 1})
assert_equal(measure.collect_entries_to_observe(),
['root/default_path'])
# Check that the notifier is correctly observed.
assert_true(measure.root_task.task_database.has_observers('notifier'))
def test_add_monitor2(self):
""" Test adding twice the same monitor second time should be a no-op.
"""
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
measure = Measure(plugin=plugin, name='Test', status='Under test')
measure.root_task = RootTask()
# Be sure that there is no observers for the database
assert_false(measure.root_task.task_database.has_observers('notifier'))
monitor_decl = plugin.monitors[u'monitor1']
measure.add_monitor(monitor_decl.id,
monitor_decl.factory(monitor_decl, self.workbench))
measure.add_monitor(monitor_decl.id,
monitor_decl.factory(monitor_decl, self.workbench))
def test_remove_monitor1(self):
""" Test removing a monitor.
"""
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
measure = Measure(plugin=plugin, name='Test', status='Under test')
measure.root_task = RootTask()
test_obs = lambda change: False
measure.root_task.task_database.observe('notifier', test_obs)
monitor_decl = plugin.monitors[u'monitor1']
measure.add_monitor(monitor_decl.id,
monitor_decl.factory(monitor_decl, self.workbench))
measure.remove_monitor(u'monitor1')
assert_not_in(u'monitor1', measure.monitors)
# Check that the notifier is not observed anymore but that other
# observers are not deleted.
assert_true(measure.root_task.task_database.has_observers('notifier'))
measure.root_task.task_database.unobserve('notifier', test_obs)
assert_false(measure.root_task.task_database.has_observers('notifier'))
def test_remove_monitor2(self):
""" Test removing a non-existent monitor (should be a no-op).
"""
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
measure = Measure(plugin=plugin, name='Test', status='Under test')
measure.root_task = RootTask()
measure.remove_monitor(u'monitor1')
def test_setting_state(self):
""" Test entering the edition state for a measure.
"""
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
measure = Measure(plugin=plugin, name='Test', status='Under test')
measure.root_task = RootTask()
# Be sure that there is no observers for the database
assert_false(measure.root_task.task_database.has_observers('notifier'))
monitor_decl = plugin.monitors[u'monitor1']
measure.add_monitor(monitor_decl.id,
monitor_decl.factory(monitor_decl, self.workbench))
assert_true(measure.root_task.task_database.has_observers('notifier'))
measure.enter_running_state()
assert_false(measure.root_task.task_database.has_observers('notifier'))
measure.enter_edition_state()
assert_true(measure.root_task.task_database.has_observers('notifier'))
def test_observer_root_task(self):
""" Test the behavior of the root_task observer.
"""
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
measure = Measure(plugin=plugin, name='Test', status='Under test')
root_task1 = RootTask()
root_task2 = RootTask()
measure.root_task = root_task1
monitor_decl = plugin.monitors[u'monitor1']
measure.add_monitor(monitor_decl.id,
monitor_decl.factory(monitor_decl, self.workbench))
measure.root_task = root_task2
assert_equal(measure.monitors[u'monitor1'].updated,
{'root/default_path': 1})
assert_equal(measure.collect_entries_to_observe(),
['root/default_path'])
assert_false(root_task1.task_database.has_observers('notifier'))
assert_true(root_task2.task_database.has_observers('notifier'))
def test_observer_name(self):
""" Test observer for measure name.
"""
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
measure = Measure(plugin=plugin, name='Test', status='Under test')
measure.root_task = RootTask()
monitor_decl = plugin.monitors[u'monitor1']
measure.add_monitor(monitor_decl.id,
monitor_decl.factory(monitor_decl, self.workbench))
measure.name = 'Test2'
assert_equal(measure.monitors[u'monitor1'].measure_name, 'Test2')
def test_observer_status(self):
""" Test observer for measure status.
"""
plugin = self.workbench.get_plugin(u'hqc_meas.measure')
measure = Measure(plugin=plugin, name='Test', status='Under test')
measure.root_task = RootTask()
monitor_decl = plugin.monitors[u'monitor1']
measure.add_monitor(monitor_decl.id,
monitor_decl.factory(monitor_decl, self.workbench))
measure.status = 'Test over'
assert_equal(measure.monitors[u'monitor1'].measure_status, 'Test over')
if __name__ == '__main__':
with enaml.imports():
from enaml.workbench.core.core_manifest import CoreManifest
from enaml.workbench.ui.ui_manifest import UIManifest
from psi.context.manifest import ContextManifest
from psi.data.manifest import DataManifest
from psi.controller.base_manifest import ControllerManifest
from psi.experiment.manifest import ExperimentManifest
with warnings.catch_warnings():
warnings.simplefilter('ignore')
workbench = Workbench()
workbench.register(CoreManifest())
workbench.register(UIManifest())
workbench.register(ContextManifest())
workbench.register(DataManifest())
workbench.register(ControllerManifest())
workbench.register(ExperimentManifest())
core = workbench.get_plugin('enaml.workbench.core')
ui = workbench.get_plugin('enaml.workbench.ui')
parameters = core.invoke_command('psi.context.get_parameters')
parameters[0].rove = True
name = parameters[0].name
class Test(object):
test_dir = ''
@classmethod
def setup_class(cls):
print complete_line(
__name__ + ':{}.setup_class()'.format(cls.__name__), '-', 77)
# Creating dummy directory for prefs (avoid prefs interferences).
directory = os.path.dirname(__file__)
cls.test_dir = os.path.join(directory, '_temps')
create_test_dir(cls.test_dir)
# Creating dummy default.ini file in utils.
util_path = os.path.join(directory, '..', '..', '..', 'hqc_meas',
'utils', 'preferences')
def_path = os.path.join(util_path, 'default.ini')
# Making the preference manager look for info in test dir.
default = ConfigObj(def_path)
default['folder'] = cls.test_dir
default['file'] = 'default_test.ini'
default.write()
# Creating tasks preferences.
task_path = os.path.join(directory, '..', '..', '..', 'hqc_meas',
'tasks')
task_api = set(
('base_tasks.py', 'instr_task.py', 'tasks_util', 'tasks_instr'))
task_loading = [
unicode('tasks.' + mod[:-3]) for mod in os.listdir(task_path)
if mod.endswith('.py') and mod not in task_api
]
task_loading.extend([
unicode('tasks.' + pack) for pack in os.listdir(task_path)
if os.path.isdir(os.path.join(task_path, pack))
and pack not in task_api
])
# Copying false template.
template_path = os.path.join(cls.test_dir, 'temp_templates')
os.mkdir(template_path)
# Not in the root test dirt otherwise .ini got deleted ...
# Not understood but unlinked to shutil.
shutil.copyfile(
os.path.join(directory, 'config_files', 'template_ref.ini'),
os.path.join(template_path, 'template.ini'))
# Saving plugin preferences.
man_conf = {
'tasks_loading': str(task_loading),
'templates_folders': str([template_path])
}
conf = ConfigObj(os.path.join(cls.test_dir, 'default_test.ini'))
conf[u'hqc_meas.task_manager'] = {}
conf[u'hqc_meas.task_manager'].update(man_conf)
conf.write()
@classmethod
def teardown_class(cls):
print complete_line(
__name__ + ':{}.teardown_class()'.format(cls.__name__), '-', 77)
# Removing pref files creating during tests.
remove_tree(cls.test_dir)
# Restoring default.ini file in utils
directory = os.path.dirname(__file__)
util_path = os.path.join(directory, '..', '..', '..', 'hqc_meas',
'utils', 'preferences')
def_path = os.path.join(util_path, 'default.ini')
os.remove(def_path)
def setup(self):
self.workbench = Workbench()
self.workbench.register(CoreManifest())
self.workbench.register(StateManifest())
self.workbench.register(PreferencesManifest())
self.workbench.register(DependenciesManifest())
def teardown(self):
self.workbench.unregister(u'hqc_meas.task_manager')
self.workbench.unregister(u'hqc_meas.preferences')
self.workbench.unregister(u'hqc_meas.state')
self.workbench.unregister(u'hqc_meas.dependencies')
self.workbench.unregister(u'enaml.workbench.core')
def test_init(self):
self.workbench.register(TaskManagerManifest())
plugin = self.workbench.get_plugin(u'hqc_meas.task_manager')
# Testing task explorations.
assert_in('Complex', plugin.tasks)
assert_not_in('Instr', plugin.tasks)
assert_in('Log', plugin.tasks)
assert_in('Definition', plugin.tasks)
assert_in('Sleep', plugin.tasks)
# Testing interface exploration
assert_in('SetDCVoltageTask', plugin._task_interfaces)
assert_not_equal(plugin._task_interfaces['SetDCVoltageTask'], [])
# Testing templates
assert_in('Template', plugin.tasks)
def test_load_all(self):
self.workbench.register(TaskManagerManifest())
plugin = self.workbench.get_plugin(u'hqc_meas.task_manager')
with plugin.suppress_notifications():
plugin.views_loading = []
plugin.tasks_loading = []
plugin.notify('tasks_loading', {})
if plugin.report():
raise SkipTest(plugin.report())
@attr('no_travis')
def test_template_observation(self):
self.workbench.register(TaskManagerManifest())
plugin = self.workbench.get_plugin(u'hqc_meas.task_manager')
assert_in('Template', plugin.tasks)
template_path = os.path.join(self.test_dir, 'temp_templates')
prof = ConfigObj(os.path.join(template_path, 'test.ini'))
prof.write()
from time import sleep
sleep(0.5)
try:
assert_in('Test', plugin.tasks)
assert_in('Template', plugin.tasks)
finally:
os.remove(os.path.join(template_path, 'test.ini'))
sleep(0.5)
assert_not_in('Test', plugin.tasks)
assert_in('Template', plugin.tasks)
def test_tasks_request1(self):
# Test requesting a task using its name.
self.workbench.register(TaskManagerManifest())
core = self.workbench.get_plugin(u'enaml.workbench.core')
com = u'hqc_meas.task_manager.tasks_request'
tasks, miss = core.invoke_command(
com, {'tasks': ['Complex', 'Sleep', 'XXXX']}, self)
from hqc_meas.tasks.api import ComplexTask
assert_equal(sorted(tasks.keys()), sorted(['Complex', 'Sleep']))
assert_in(ComplexTask, tasks.values())
assert_equal(miss, ['XXXX'])
def test_tasks_request2(self):
# Test requesting a task using its class name.
self.workbench.register(TaskManagerManifest())
core = self.workbench.get_plugin(u'enaml.workbench.core')
com = u'hqc_meas.task_manager.tasks_request'
tasks, miss = core.invoke_command(com, {
'tasks': ['ComplexTask', 'SleepTask'],
'use_class_names': True
}, self)
from hqc_meas.tasks.api import ComplexTask
assert_equal(sorted(tasks.keys()), sorted(['ComplexTask',
'SleepTask']))
assert_in(ComplexTask, tasks.values())
assert_equal(miss, [])
def test_interface_request1(self):
# Test requesting interfaces using the task class name
self.workbench.register(TaskManagerManifest())
core = self.workbench.get_plugin(u'enaml.workbench.core')
com = u'hqc_meas.task_manager.interfaces_request'
interfaces, miss = core.invoke_command(
com, {'tasks': ['SetDCVoltageTask', 'XXXX']}, self)
assert_equal(interfaces.keys(), ['SetDCVoltageTask'])
assert_equal(miss, ['XXXX'])
def test_interfaces_request2(self):
# Test requesting interfaces using the interface class name
self.workbench.register(TaskManagerManifest())
core = self.workbench.get_plugin(u'enaml.workbench.core')
com = u'hqc_meas.task_manager.interfaces_request'
kwargs = {'interfaces': ['MultiChannelVoltageSourceInterface']}
inter, miss = core.invoke_command(com, kwargs, self)
assert_equal(inter.keys(), ['MultiChannelVoltageSourceInterface'])
def test_views_request(self):
self.workbench.register(TaskManagerManifest())
core = self.workbench.get_plugin(u'enaml.workbench.core')
com = u'hqc_meas.task_manager.views_request'
with enaml.imports():
from hqc_meas.tasks.views.base_task_views import ComplexView
views, miss = core.invoke_command(com,
{'task_classes': ['ComplexTask']},
self)
assert_in('ComplexTask', views)
assert_equal(views['ComplexTask'], ComplexView)
assert_equal(miss, [])
def test_interface_views_request1(self):
self.workbench.register(TaskManagerManifest())
core = self.workbench.get_plugin(u'enaml.workbench.core')
com = u'hqc_meas.task_manager.interface_views_request'
kwargs = {'interface_classes': ['MultiChannelVoltageSourceInterface']}
views, miss = core.invoke_command(com, kwargs, self)
assert_in('MultiChannelVoltageSourceInterface', views)
assert_equal(miss, [])
def test_filter_tasks(self):
self.workbench.register(TaskManagerManifest())
plugin = self.workbench.get_plugin(u'hqc_meas.task_manager')
core = self.workbench.get_plugin(u'enaml.workbench.core')
com = u'hqc_meas.task_manager.filter_tasks'
tasks = core.invoke_command(com, {'filter': 'All'}, self)
assert_equal(sorted(tasks), sorted(plugin.tasks))
tasks = core.invoke_command(com, {'filter': 'Python'}, self)
assert_equal(sorted(tasks), sorted(plugin._py_tasks.keys()))
tasks = core.invoke_command(com, {'filter': 'Template'}, self)
assert_equal(sorted(tasks), sorted(plugin._template_tasks.keys()))
# These two tests are sufficient to ensure that subclass tests works
tasks = core.invoke_command(com, {'filter': 'Simple'}, self)
assert_not_in('Complex', tasks)
assert_in('Log', tasks)
tasks = core.invoke_command(com, {'filter': 'Complex'}, self)
assert_not_in('Log', tasks)
assert_in('Complex', tasks)
# Test the class attr filter
tasks = core.invoke_command(com, {'filter': 'Loopable'}, self)
assert_not_in('Definition', tasks)
assert_in('Log', tasks)
def test_config_request_build1(self):
self.workbench.register(TaskManagerManifest())
core = self.workbench.get_plugin(u'enaml.workbench.core')
com = u'hqc_meas.task_manager.config_request'
conf, view = core.invoke_command(com, {'task': 'Log'}, self)
assert_equal(type(conf).__name__, 'PyConfigTask')
conf.task_name = 'Test'
assert_equal(conf.config_ready, True)
task = conf.build_task()
assert_equal(task.task_name, 'Test')
def test_config_request_build2(self):
self.workbench.register(TaskManagerManifest())
core = self.workbench.get_plugin(u'enaml.workbench.core')
com = u'hqc_meas.task_manager.config_request'
conf, view = core.invoke_command(com, {'task': 'Template'}, self)
assert_equal(type(conf).__name__, 'IniConfigTask')
conf.task_name = 'Test'
assert_equal(conf.config_ready, True)
task = conf.build_task()
assert_equal(task.task_name, 'Test')
assert_equal(len(task.children_task), 1)
task2 = task.children_task[0]
assert_equal(task2.task_name, 'a')
assert_equal(task2.task_class, 'LogTask')
def test_config_request_build3(self):
self.workbench.register(TaskManagerManifest())
core = self.workbench.get_plugin(u'enaml.workbench.core')
com = u'hqc_meas.task_manager.config_request'
plugin = self.workbench.get_plugin(u'hqc_meas.task_manager')
if u'tasks.tasks_logic' in plugin.tasks_loading:
aux = plugin.tasks_loading[:]
aux.remove(u'tasks.tasks_logic')
plugin.tasks_loading = aux
conf, view = core.invoke_command(com, {'task': 'Loop'}, self)
assert_equal(type(conf).__name__, 'LoopConfigTask')
conf.task_name = 'Test'
conf.subtask = 'Log'
assert_equal(conf.config_ready, True)
task = conf.build_task()
assert_equal(task.task_name, 'Test')
def test_collect_dependencies(self):
# Test collecting build dependencies.
self.workbench.register(TaskManagerManifest())
from hqc_meas.tasks.api import RootTask, ComplexTask
from hqc_meas.tasks.tasks_util.log_task import LogTask
aux = [LogTask(task_name='r')]
root = RootTask(task_name='root')
root.children_task = [
ComplexTask(task_name='complex', children_task=aux),
LogTask(task_name='t')
]
core = self.workbench.get_plugin(u'enaml.workbench.core')
com = u'hqc_meas.dependencies.collect_dependencies'
res, build, run = core.invoke_command(com, {'obj': root}, core)
assert_true(res)
assert_in('tasks', build)
assert_equal(sorted(['LogTask', 'ComplexTask']),
sorted(build['tasks'].keys()))
assert_not_in('interfaces', build)
assert_false(run)
class TestExtensionsCollector(object):
"""Test the ExtensionsCollector behaviour.
"""
def setup(self):
self.workbench = Workbench()
self.workbench.register(CoreManifest())
self.workbench.register(ErrorsManifest())
self.workbench.register(ExtensionManifest())
def test_registation1(self, exopy_qtbot):
"""Test that plugin registered before starting the plugin are well
detected
"""
c = Contributor1()
self.workbench.register(c)
plugin = self.workbench.get_plugin(PLUGIN_ID)
assert 'contrib1.contrib' in plugin.contribs.contributions
self.workbench.unregister(c.id)
assert 'contrib1.contrib' not in plugin.contribs.contributions
assert not plugin.contribs._extensions
plugin.contribs.stop()
assert not plugin.contribs.contributions
def test_registration2(self, exopy_qtbot):
"""Test contribs update when a new plugin is registered.
"""
self.workbench.register(Contributor2())
plugin = self.workbench.get_plugin(PLUGIN_ID)
c = Contributor1()
self.workbench.register(c)
assert 'contrib1.contrib' in plugin.contribs.contributions
self.workbench.unregister(c.id)
assert 'contrib1.contrib' not in plugin.contribs.contributions
def test_factory(self, exopy_qtbot):
"""Test getting the Contribution declaration from a factory.
"""
c = Contributor2()
self.workbench.register(c)
plugin = self.workbench.get_plugin(PLUGIN_ID)
assert 'contrib2.contrib' in plugin.contribs.contributions
self.workbench.unregister(c.id)
assert 'contrib2.contrib' not in plugin.contribs.contributions
@pytest.mark.ui
def test_errors1(self, exopy_qtbot):
"""Test uniqueness of contribution id.
"""
self.workbench.register(Contributor1())
self.workbench.register(Contributor1(id='bis'))
self.workbench.register(Contributor1(id='ter'))
with handle_dialog(exopy_qtbot):
self.workbench.get_plugin(PLUGIN_ID)
@pytest.mark.ui
def test_check_errors2(self, exopy_qtbot):
"""Test use of validate_ext.
"""
self.workbench.register(Contributor3())
with handle_dialog(exopy_qtbot):
self.workbench.get_plugin(PLUGIN_ID)
def test_check_errors3(self, exopy_qtbot):
"""Test enforcement of type when using factory.
"""
self.workbench.register(Contributor4())
with handle_dialog(exopy_qtbot):
self.workbench.get_plugin(PLUGIN_ID)
def test_declared_by(self):
"""Test getting the extension declaring a particular contribution.
"""
c = Contributor1()
self.workbench.register(c)
plugin = self.workbench.get_plugin(PLUGIN_ID)
assert plugin.contribs.contributed_by('contrib1.contrib') is \
c.extensions[0]
class TestTemplateConfig(object):
"""
"""
test_dir = ''
@classmethod
def setup_class(cls):
print complete_line(__name__ +
':{}.setup_class()'.format(cls.__name__), '-', 77)
# Creating dummy directory for prefs (avoid prefs interferences).
cls.test_dir = os.path.join(FILE_DIR, '_temps')
create_test_dir(cls.test_dir)
# Creating dummy default.ini file in utils.
util_path = os.path.join(PACKAGE_PATH, 'utils', 'preferences')
def_path = os.path.join(util_path, 'default.ini')
# Making the preference manager look for info in test dir.
default = ConfigObj(def_path)
default['folder'] = cls.test_dir
default['file'] = 'default_test.ini'
default.write()
# Creating a false template.
template_path = os.path.join(cls.test_dir, 'temp_templates')
os.mkdir(template_path)
conf = ConfigObj()
conf.filename = os.path.join(template_path, 'test.ini')
conf.update(create_template_sequence())
conf.write()
# Saving plugin preferences.
man_conf = {'templates_folders': repr([template_path])}
conf = ConfigObj(os.path.join(cls.test_dir, 'default_test.ini'))
conf[u'hqc_meas.pulses'] = {}
conf[u'hqc_meas.pulses'].update(man_conf)
conf.write()
@classmethod
def teardown_class(cls):
print complete_line(__name__ +
':{}.teardown_class()'.format(cls.__name__), '-',
77)
# Removing pref files creating during tests.
remove_tree(cls.test_dir)
# Restoring default.ini file in utils
util_path = os.path.join(PACKAGE_PATH, 'utils', 'preferences')
def_path = os.path.join(util_path, 'default.ini')
os.remove(def_path)
def setup(self):
self.workbench = Workbench()
self.workbench.register(CoreManifest())
self.workbench.register(StateManifest())
self.workbench.register(PreferencesManifest())
self.workbench.register(DependenciesManifest())
self.workbench.register(PulsesManagerManifest())
self.plugin = self.workbench.get_plugin('hqc_meas.pulses')
def teardown(self):
self.workbench.unregister(u'hqc_meas.pulses')
self.workbench.unregister(u'hqc_meas.dependencies')
self.workbench.unregister(u'hqc_meas.preferences')
self.workbench.unregister(u'hqc_meas.state')
self.workbench.unregister(u'enaml.workbench.core')
def test_init(self):
# Test the context is properly created at config init.
seqs, _ = self.plugin.sequences_request(['Test'])
_, conf, doc = seqs['Test']
t_config = TemplateConfig(template_doc=doc, template_config=conf)
assert_items_equal(t_config.context.logical_channels, ['A', 'B'])
assert_items_equal(t_config.context.analogical_channels,
['Ch1', 'Ch2'])
assert_equal(t_config.context.channel_mapping,
{'A': '', 'B': '', 'Ch1': '', 'Ch2': ''})
def test_building_template1(self):
# Test building a template.
seqs, _ = self.plugin.sequences_request(['Test'])
_, conf, doc = seqs['Test']
t_config = TemplateConfig(template_doc=doc, template_config=conf,
manager=self.plugin)
t_config.template_name = 'Test'
seq = t_config.build_sequence()
assert_false(t_config.errors)
assert_is_instance(seq, TemplateSequence)
assert_equal(seq.name, 'Test')
# No need to check more as build_from_config is already tested in
# test_template_sequence.
def test_building_template2(self):
# Test building a template for which some dependencies are missing.
del self.plugin._sequences['Pulse']
seqs, _ = self.plugin.sequences_request(['Test'])
_, conf, doc = seqs['Test']
t_config = TemplateConfig(template_doc=doc, template_config=conf,
manager=self.plugin)
t_config.template_name = 'Test'
seq = t_config.build_sequence()
assert_true(t_config.errors)
assert_is(seq, None)
def test_merging_template1(self):
# Test merging a template.
seqs, _ = self.plugin.sequences_request(['Test'])
_, conf, doc = seqs['Test']
test_conf = conf.copy()
t_config = TemplateConfig(template_doc=doc, template_config=conf,
manager=self.plugin)
t_config.template_name = 'Test'
t_config.merge = True
t_config.root = RootSequence()
t_config.context.channel_mapping =\
{'A': 'Ch1_M1', 'Ch1': 'Ch3'}
seq = t_config.build_sequence()
assert_false(t_config.errors)
assert_is_instance(seq, Sequence)
assert_equal(seq.name, 'Test')
loc_vars = literal_eval(test_conf['local_vars'])
loc_vars.update(literal_eval(test_conf['template_vars']))
assert_equal(seq.local_vars, loc_vars)
assert_false(t_config.root.external_vars)
assert_equal(seq.items[0].channel, 'Ch1_M1')
assert_equal(seq.items[1].channel, '')
assert_equal(seq.items[2].items[0].channel, '')
assert_equal(seq.items[3].channel, 'Ch3')
def test_merging_template2(self):
# Test merging a template.
seqs, _ = self.plugin.sequences_request(['Test'])
_, conf, doc = seqs['Test']
test_conf = conf.copy()
t_config = TemplateConfig(template_doc=doc, template_config=conf,
manager=self.plugin)
t_config.template_name = 'Test'
t_config.merge = True
t_config.t_vars_as_root = True
t_config.root = RootSequence()
t_config.context.channel_mapping =\
{'A': 'Ch1_M1', 'Ch1': 'Ch3'}
seq = t_config.build_sequence()
assert_false(t_config.errors)
assert_is_instance(seq, Sequence)
assert_equal(seq.name, 'Test')
assert_equal(seq.local_vars, literal_eval(test_conf['local_vars']))
assert_equal(t_config.root.external_vars,
literal_eval(test_conf['template_vars']))
assert_equal(seq.items[0].channel, 'Ch1_M1')
assert_equal(seq.items[1].channel, '')
assert_equal(seq.items[2].items[0].channel, '')
assert_equal(seq.items[3].channel, 'Ch3')
class TestSetDCVoltageView(object):
def setup(self):
self.workbench = Workbench()
self.workbench.register(CoreManifest())
self.workbench.register(StateManifest())
self.workbench.register(PreferencesManifest())
self.workbench.register(InstrManagerManifest())
self.workbench.register(TaskManagerManifest())
self.root = RootTask(should_stop=Event(), should_pause=Event())
self.task = MeasDCVoltageTask(task_name='Test')
self.root.children_task.append(self.task)
self.root.run_time['drivers'] = {'Test': InstrHelper}
def teardown(self):
close_all_windows()
self.workbench.unregister(u'hqc_meas.task_manager')
self.workbench.unregister(u'hqc_meas.instr_manager')
self.workbench.unregister(u'hqc_meas.preferences')
self.workbench.unregister(u'hqc_meas.state')
self.workbench.unregister(u'enaml.workbench.core')
def test_view1(self):
# Intantiate a view with no selected interface and select one after
window = enaml.widgets.api.Window()
core = self.workbench.get_plugin('enaml.workbench.core')
view = DCVoltMeasView(window, task=self.task, core=core)
window.show()
process_app_events()
class TestCollectingFromConfig(object):
"""Test collecting dependencies from ConfigObj object.
"""
def setup(self):
self.workbench = Workbench()
self.workbench.register(CoreManifest())
self.workbench.register(DependenciesManifest())
self.workbench.register(BuildDep())
def teardown(self):
self.workbench.unregister('ecpy.app.dependencies')
self.workbench.unregister('enaml.workbench.core')
def test_collecting(self):
"""Test collecting from a dict-like object.
"""
core = self.workbench.get_plugin('enaml.workbench.core')
res, dep = core.invoke_command(COLLECT,
{'obj': ConfigObj({'val': '1',
'dep_type': 'test'})}
)
assert res
assert dep.keys() == ['test']
def test_handling_errors(self, monkeypatch):
"""Test handling errors occuring when collecting dependencies.
"""
plugin = self.workbench.get_plugin('ecpy.app.dependencies')
for b in plugin.build_deps.contributions.values():
monkeypatch.setattr(b, 'err', True)
core = self.workbench.get_plugin('enaml.workbench.core')
res, dep = core.invoke_command(COLLECT,
{'obj': ConfigObj({'val': '1',
'dep_type': 'test'})}
)
assert not res
assert 'test' in dep
class TestDeclaratorCollector(object):
"""Test the ExtensionsCollector behaviour.
"""
def setup(self):
self.workbench = Workbench()
self.workbench.register(CoreManifest())
self.workbench.register(ErrorsManifest())
self.workbench.register(DeclaratorManifest())
def test_registation1(self, exopy_qtbot):
"""Test that plugin registered before starting the plugin are well
detected
"""
d = DContributor1()
self.workbench.register(d)
plugin = self.workbench.get_plugin(PLUGIN_ID)
assert 'contrib1' in plugin.contribs.contributions
self.workbench.unregister(d.id)
assert not plugin.contribs.contributions
assert not plugin.contribs._extensions
def test_registration2(self, exopy_qtbot):
"""Test contribs update when a new plugin is registered.
"""
class Witness(object):
called = 0
def see(self, change):
print('r')
self.called += 1
w = Witness()
self.workbench.register(DContributor2())
plugin = self.workbench.get_plugin(PLUGIN_ID)
plugin.contribs.observe('contributions', w.see)
d = DContributor1()
self.workbench.register(d)
assert 'contrib1' in plugin.contribs.contributions
assert w.called == 1
self.workbench.unregister(d.id)
assert 'contrib1' not in plugin.contribs.contributions
assert w.called == 2
plugin.contribs.stop()
assert not plugin.contribs.contributions
assert w.called == 2
assert not plugin.contribs._extensions
def test_factory(self, exopy_qtbot):
"""Test getting the TestDeclarator declaration from a factory.
"""
d = DContributor2()
self.workbench.register(d)
plugin = self.workbench.get_plugin(PLUGIN_ID)
assert 'contrib2' in plugin.contribs.contributions
self.workbench.unregister(d.id)
assert not plugin.contribs.contributions
def test_check_errors1(self, exopy_qtbot):
"""Test enforcement of type when using factory.
"""
self.workbench.register(DContributor3())
with handle_dialog(exopy_qtbot):
self.workbench.get_plugin(PLUGIN_ID)
@pytest.mark.ui
def test_declarator_failed_registration(self, exopy_qtbot):
"""Test handling of error when a declarator fail to register.
"""
self.workbench.register(DContributor4())
with handle_dialog(exopy_qtbot):
self.workbench.get_plugin(PLUGIN_ID)
@pytest.mark.ui
def test_unsatifiable_requirement(self, exopy_qtbot):
"""Test the case of a declarator always adding itself to _deflayed.
"""
self.workbench.register(DContributor5())
with handle_dialog(exopy_qtbot):
self.workbench.get_plugin(PLUGIN_ID)
class TestPlugin(object):
def setup(self):
self.workbench = Workbench()
self.workbench.register(CoreManifest())
self.workbench.register(DependenciesManifest())
def teardown(self):
self.workbench.unregister(u'hqc_meas.dependencies')
self.workbench.unregister(u'enaml.workbench.core')
# --- Test BuildDependencies ----------------------------------------------
def test_build_dep_registation1(self):
# Test that build deps are properly found at start-up.
self.workbench.register(DummyBuildDep1())
plugin = self.workbench.get_plugin(u'hqc_meas.dependencies')
assert_in(u'dummy.build_dep1', plugin.build_collectors)
self.workbench.unregister(u'dummy.build_dep1')
assert_not_in(u'dummy.build_dep1', plugin.build_collectors)
def test_build_dep_registration2(self):
# Test build deps update when a new plugin is registered.
plugin = self.workbench.get_plugin(u'hqc_meas.dependencies')
self.workbench.register(DummyBuildDep1())
assert_in(u'dummy.build_dep1', plugin.build_collectors)
self.workbench.unregister(u'dummy.build_dep1')
assert_not_in(u'dummy.build_dep1', plugin.build_collectors)
def test_build_dep_factory(self):
# Test getting the BuildDependency decl from a factory.
self.workbench.register(DummyBuildDep2())
plugin = self.workbench.get_plugin(u'hqc_meas.dependencies')
assert_in(u'dummy.build_dep2', plugin.build_collectors)
self.workbench.unregister(u'dummy.build_dep2')
assert_not_in(u'dummy.build_dep1', plugin.build_collectors)
@raises(ValueError)
def test_build_dep_errors1(self):
# Test uniqueness of BuildDependency id.
self.workbench.register(DummyBuildDep1())
self.workbench.register(DummyBuildDep1bis())
self.workbench.get_plugin(u'hqc_meas.dependencies')
@raises(ValueError)
def test_build_dep_errors2(self):
# Test presence of dependencies in BuildDependency.
self.workbench.register(DummyBuildDep3())
self.workbench.get_plugin(u'hqc_meas.dependencies')
@raises(ValueError)
def test_build_dep_errors3(self):
# Test presence of collect in BuildDependency.
self.workbench.register(DummyBuildDep4())
self.workbench.get_plugin(u'hqc_meas.dependencies')
@raises(TypeError)
def test_build_dep_errors4(self):
# Test enforcement of type for BuildDependency when using factory.
self.workbench.register(DummyBuildDep5())
self.workbench.get_plugin(u'hqc_meas.dependencies')
# --- Test RuntimeDependencies --------------------------------------------
def test_runtime_dep_registation1(self):
# Test that runtime deps are properly found at start-up.
self.workbench.register(DummyRuntimeDep1())
plugin = self.workbench.get_plugin(u'hqc_meas.dependencies')
assert_in(u'dummy.runtime_dep1', plugin.runtime_collectors)
self.workbench.unregister(u'dummy.runtime_dep1')
assert_not_in(u'dummy.runtime_dep1', plugin.runtime_collectors)
assert_equal(plugin._runtime_extensions, {})
def test_runtime_dep_registration2(self):
# Test runtime deps update when a new plugin is registered.
plugin = self.workbench.get_plugin(u'hqc_meas.dependencies')
self.workbench.register(DummyRuntimeDep1())
assert_in(u'dummy.runtime_dep1', plugin.runtime_collectors)
self.workbench.unregister(u'dummy.runtime_dep1')
assert_not_in(u'dummy.runtime_dep1', plugin.runtime_collectors)
def test_runtime_dep_factory(self):
# Test getting the RuntimeDependency decl from a factory.
self.workbench.register(DummyRuntimeDep2())
plugin = self.workbench.get_plugin(u'hqc_meas.dependencies')
assert_in(u'dummy.runtime_dep2', plugin.runtime_collectors)
self.workbench.unregister(u'dummy.runtime_dep2')
assert_not_in(u'dummy.runtime_dep2', plugin.runtime_collectors)
@raises(ValueError)
def test_runtime_dep_errors1(self):
# Test uniqueness of RuntimeDependency id.
self.workbench.register(DummyRuntimeDep1())
self.workbench.register(DummyRuntimeDep1bis())
self.workbench.get_plugin(u'hqc_meas.dependencies')
@raises(ValueError)
def test_runtime_dep_errors2(self):
# Test presence of dependencies in RuntimeDependency.
self.workbench.register(DummyRuntimeDep3())
self.workbench.get_plugin(u'hqc_meas.dependencies')
@raises(ValueError)
def test_runtime_dep_errors3(self):
# Test presence of collect in RuntimeDependency.
self.workbench.register(DummyRuntimeDep4())
self.workbench.get_plugin(u'hqc_meas.dependencies')
@raises(TypeError)
def test_runtime_dep_errors4(self):
# Test enforcement of type for RuntimeDependency when using factory.
self.workbench.register(DummyRuntimeDep5())
self.workbench.get_plugin(u'hqc_meas.dependencies')
class TestDebugSpace(object):
test_dir = ''
@classmethod
def setup_class(cls):
print complete_line(
__name__ + ':{}.setup_class()'.format(cls.__name__), '-', 77)
# Creating dummy directory for prefs (avoid prefs interferences).
directory = os.path.dirname(__file__)
cls.test_dir = os.path.join(directory, '_temps')
create_test_dir(cls.test_dir)
# Creating dummy default.ini file in utils.
util_path = os.path.join(directory, '..', '..', 'hqc_meas', 'utils',
'preferences')
def_path = os.path.join(util_path, 'default.ini')
# Making the preference manager look for info in test dir.
default = ConfigObj(def_path)
default['folder'] = cls.test_dir
default['file'] = 'default_test.ini'
default.write()
conf = ConfigObj(os.path.join(cls.test_dir, 'default_test.ini'))
conf.write()
@classmethod
def teardown_class(cls):
print complete_line(
__name__ + ':{}.teardown_class()'.format(cls.__name__), '-', 77)
# Removing pref files creating during tests.
remove_tree(cls.test_dir)
# Restoring default.ini file in utils
directory = os.path.dirname(__file__)
util_path = os.path.join(directory, '..', '..', 'hqc_meas', 'utils',
'preferences')
def_path = os.path.join(util_path, 'default.ini')
os.remove(def_path)
def setup(self):
self.workbench = Workbench()
self.workbench.register(CoreManifest())
self.workbench.register(UIManifest())
self.workbench.register(HqcAppManifest())
self.workbench.register(StateManifest())
self.workbench.register(PreferencesManifest())
self.workbench.register(LogManifest())
self.workbench.register(TaskManagerManifest())
self.workbench.register(InstrManagerManifest())
self.workbench.register(DebuggerManifest())
self.workbench.register(TestSuiteManifest())
def teardown(self):
core = self.workbench.get_plugin(u'enaml.workbench.core')
core.invoke_command(u'enaml.workbench.ui.close_workspace', {}, self)
self.workbench.unregister(u'hqc_meas.debug')
self.workbench.unregister(u'tests.suite')
self.workbench.unregister(u'hqc_meas.task_manager')
self.workbench.unregister(u'hqc_meas.instr_manager')
self.workbench.unregister(u'hqc_meas.logging')
self.workbench.unregister(u'hqc_meas.preferences')
self.workbench.unregister(u'hqc_meas.state')
self.workbench.unregister(u'hqc_meas.app')
self.workbench.unregister(u'enaml.workbench.ui')
self.workbench.unregister(u'enaml.workbench.core')
close_all_windows()
def test_life_cycle1(self):
""" Test that workspace starting/closing goes well.
"""
plugin = self.workbench.get_plugin(u'hqc_meas.debug')
core = self.workbench.get_plugin(u'enaml.workbench.core')
cmd = u'enaml.workbench.ui.select_workspace'
core.invoke_command(cmd, {'workspace': u'hqc_meas.debug.workspace'},
self)
log_plugin = self.workbench.get_plugin(u'hqc_meas.logging')
# Check the plugin got the workspace
assert_true(plugin.workspace)
workspace = plugin.workspace
# Check the contribution of the debugger was added to the workspace.
assert_true(tester.contributing)
ui = self.workbench.get_plugin('enaml.workbench.ui')
ui.show_window()
process_app_events()
# Check the workspace registration.
assert_true(workspace.log_model)
assert_in(LOG_ID, log_plugin.handler_ids)
logger = logging.getLogger(__name__)
logger.info('test')
process_app_events()
assert_in('test', workspace.log_model.text)
cmd = u'enaml.workbench.ui.close_workspace'
core.invoke_command(cmd, {}, self)
# Check the workspace removed its log handler.
assert_not_in(LOG_ID, log_plugin.handler_ids)
# Check the reference to the workspace was destroyed.
assert_equal(plugin.workspace, None)
# Check the contribution of the debugger to the workspace was removed.
assert_false(tester.contributing)
def test_life_cycle2(self):
""" Test that workspace reselection do restore debug panels.
"""
plugin = self.workbench.get_plugin(u'hqc_meas.debug')
core = self.workbench.get_plugin(u'enaml.workbench.core')
cmd = u'enaml.workbench.ui.select_workspace'
core.invoke_command(cmd, {'workspace': u'hqc_meas.debug.workspace'},
self)
# Check the plugin got the workspace
assert_true(plugin.workspace)
workspace = plugin.workspace
ui = self.workbench.get_plugin('enaml.workbench.ui')
ui.show_window()
process_app_events()
# Creating debuggers.
workspace.create_debugger('debugger1')
process_app_events()
workspace.create_debugger('debugger1')
process_app_events()
d_view1 = workspace.dock_area.find('item_1')
assert_is_instance(d_view1, TestDebuggerView)
d_view2 = workspace.dock_area.find('item_2')
assert_is_instance(d_view2, TestDebuggerView)
del workspace
# Closing workspace
cmd = u'enaml.workbench.ui.close_workspace'
core.invoke_command(cmd, {}, self)
process_app_events()
# Check the debugger released their ressources.
for debugger in plugin.debugger_instances:
assert_true(debugger.released)
# Reopening workspace.
cmd = u'enaml.workbench.ui.select_workspace'
core.invoke_command(cmd, {'workspace': u'hqc_meas.debug.workspace'},
self)
process_app_events()
workspace = plugin.workspace
# Checking the debuggers are there.
dock_area = workspace.dock_area
d_view1 = dock_area.find('item_1')
assert_is_instance(d_view1, TestDebuggerView)
d_view2 = dock_area.find('item_2')
assert_is_instance(d_view2, TestDebuggerView)
def test_create_debugger1(self):
""" Creating a debugger.
"""
plugin = self.workbench.get_plugin(u'hqc_meas.debug')
core = self.workbench.get_plugin(u'enaml.workbench.core')
cmd = u'enaml.workbench.ui.select_workspace'
core.invoke_command(cmd, {'workspace': u'hqc_meas.debug.workspace'},
self)
# Check the plugin got the workspace
assert_true(plugin.workspace)
workspace = plugin.workspace
ui = self.workbench.get_plugin('enaml.workbench.ui')
ui.show_window()
process_app_events()
workspace.create_debugger('debugger1')
process_app_events()
assert_true(plugin.debugger_instances)
assert_is_instance(plugin.debugger_instances[0], TestDebugger)
dock_area = workspace.dock_area
d_view = dock_area.find('item_1')
assert_is_instance(d_view, TestDebuggerView)
def test_create_debugger2(self):
""" Creating a debugger with wrong id.
"""
plugin = self.workbench.get_plugin(u'hqc_meas.debug')
core = self.workbench.get_plugin(u'enaml.workbench.core')
cmd = u'enaml.workbench.ui.select_workspace'
core.invoke_command(cmd, {'workspace': u'hqc_meas.debug.workspace'},
self)
# Check the plugin got the workspace
assert_true(plugin.workspace)
workspace = plugin.workspace
ui = self.workbench.get_plugin('enaml.workbench.ui')
ui.show_window()
process_app_events()
workspace.create_debugger('debugger_false')
process_app_events()
assert_false(plugin.debugger_instances)
def test_closing_debugger_panel(self):
""" Test closing a debugger panel and reopening one.
"""
plugin = self.workbench.get_plugin(u'hqc_meas.debug')
core = self.workbench.get_plugin(u'enaml.workbench.core')
cmd = u'enaml.workbench.ui.select_workspace'
core.invoke_command(cmd, {'workspace': u'hqc_meas.debug.workspace'},
self)
# Check the plugin got the workspace
assert_true(plugin.workspace)
workspace = plugin.workspace
ui = self.workbench.get_plugin('enaml.workbench.ui')
ui.show_window()
process_app_events()
workspace.create_debugger('debugger1')
process_app_events()
workspace.create_debugger('debugger1')
process_app_events()
workspace.create_debugger('debugger1')
process_app_events()
debugger = plugin.debugger_instances[1]
item = workspace.dock_area.find('item_2')
item.proxy.widget.close()
process_app_events()
item.destroy()
process_app_events()
assert_equal(len(workspace.dock_area.dock_items()), 3)
assert_equal(len(plugin.debugger_instances), 2)
assert_true(debugger.released)
workspace.create_debugger('debugger1')
process_app_events()
assert_equal(len(plugin.debugger_instances), 3)
assert_true(workspace.dock_area.find('item_2'))
class TestLoadArrayView(object):
def setup(self):
self.workbench = Workbench()
self.workbench.register(CoreManifest())
self.workbench.register(StateManifest())
self.workbench.register(PreferencesManifest())
self.workbench.register(TaskManagerManifest())
self.root = RootTask(should_stop=Event(), should_pause=Event())
self.task = LoadArrayTask(task_name='Test')
self.root.children_task.append(self.task)
def teardown(self):
close_all_windows()
self.workbench.unregister(u'hqc_meas.task_manager')
self.workbench.unregister(u'hqc_meas.preferences')
self.workbench.unregister(u'hqc_meas.state')
self.workbench.unregister(u'enaml.workbench.core')
def test_view(self):
# Intantiate a view with no selected interface and select one after
window = enaml.widgets.api.Window()
core = self.workbench.get_plugin('enaml.workbench.core')
view = LoadArrayView(window, task=self.task, core=core)
window.show()
process_app_events()
assert_is(self.task.interface, None)
assert_in('CSV', view.file_formats)
self.task.selected_format = 'CSV'
process_app_events()
assert_is_instance(self.task.interface,
CSVLoadInterface)
def test_view2(self):
# Intantiate a view with a selected interface.
interface = CSVLoadInterface()
self.task.interface = interface
self.task.selected_format = 'CSV'
interface = self.task.interface
window = enaml.widgets.api.Window()
core = self.workbench.get_plugin('enaml.workbench.core')
LoadArrayView(window, task=self.task, core=core)
window.show()
process_app_events()
assert_is(self.task.interface, interface)
class TestPlugin(object):
test_dir = ''
@classmethod
def setup_class(cls):
print complete_line(
__name__ + ':{}.setup_class()'.format(cls.__name__), '-', 77)
# Creating dummy directory for prefs (avoid prefs interferences).
directory = os.path.dirname(__file__)
cls.test_dir = os.path.join(directory, '_temps')
create_test_dir(cls.test_dir)
# Creating dummy default.ini file in utils.
util_path = os.path.join(directory, '..', '..', '..', 'hqc_meas',
'utils', 'preferences')
def_path = os.path.join(util_path, 'default.ini')
# Making the preference manager look for info in test dir.
default = ConfigObj(def_path)
default['folder'] = cls.test_dir
default['file'] = 'default_test.ini'
default.write()
conf = ConfigObj(os.path.join(cls.test_dir, 'default_test.ini'))
path = u'hqc_meas.measurement.monitors.text_monitor'
prefs = {'manifests': repr([(path, 'TextMonitorManifest')])}
conf[u'hqc_meas.measure'] = prefs
path = u'hqc_meas.measure.monitors.text_monitor'
rule1 = {
'class_name': 'FormatRule',
'name': 'test_format',
'suffixes': repr(['a', 'b']),
'new_entry_formatting': '{a}/{b}',
'new_entry_suffix': 'c'
}
rule2 = {
'class_name': 'RejectRule',
'name': 'test_reject',
'suffixes': repr(['a', 'b'])
}
conf[path] = {
'rules': repr({
'rule1': rule1,
'rule2': rule2
}),
'default_rules': repr(['rule1'])
}
conf.write()
@classmethod
def teardown_class(cls):
print complete_line(
__name__ + ':{}.teardown_class()'.format(cls.__name__), '-', 77)
# Removing pref files creating during tests.
remove_tree(cls.test_dir)
# Restoring default.ini file in utils
directory = os.path.dirname(__file__)
util_path = os.path.join(directory, '..', '..', '..', 'hqc_meas',
'utils', 'preferences')
def_path = os.path.join(util_path, 'default.ini')
os.remove(def_path)
def setup(self):
self.workbench = Workbench()
self.workbench.register(CoreManifest())
self.workbench.register(UIManifest())
self.workbench.register(StateManifest())
self.workbench.register(PreferencesManifest())
self.workbench.register(LogManifest())
self.workbench.register(MeasureManifest())
# Needed otherwise the monitor manifest is not registered.
self.workbench.get_plugin(u'hqc_meas.measure')
def teardown(self):
self.workbench.unregister(u'hqc_meas.measure')
self.workbench.unregister(u'hqc_meas.logging')
self.workbench.unregister(u'hqc_meas.preferences')
self.workbench.unregister(u'hqc_meas.state')
self.workbench.unregister(u'enaml.workbench.ui')
self.workbench.unregister(u'enaml.workbench.core')
def test_plugin_build_rule(self):
""" Test building a rule.
"""
config = {
'class_name': 'RejectRule',
'name': 'test_reject',
'suffixes': repr(['a', 'b'])
}
id_pl = u'hqc_meas.measure.monitors.text_monitor'
plugin = self.workbench.get_plugin(id_pl)
rule = plugin.build_rule(config)
assert_equal(rule.name, 'test_reject')
assert_equal(rule.suffixes, ['a', 'b'])
assert_equal(rule.__class__.__name__, 'RejectRule')
assert_is(plugin.build_rule({'class_name': None}), None)
def test_plugin_create_monitor1(self):
""" Test creating a default monitor using the plugin.
"""
id_pl = u'hqc_meas.measure.monitors.text_monitor'
plugin = self.workbench.get_plugin(id_pl)
monitor = plugin.create_monitor()
assert_equal(monitor._plugin, plugin)
assert_true(monitor.declaration)
assert_true(monitor.rules)
rule = monitor.rules[0]
assert_equal(rule.__class__.__name__, 'FormatRule')
assert_equal(rule.name, 'test_format')
assert_equal(rule.suffixes, ['a', 'b'])
assert_equal(rule.new_entry_formatting, '{a}/{b}')
assert_equal(rule.new_entry_suffix, 'c')
def test_plugin_create_monitor(self):
""" Test creating a raw monitor using the plugin.
"""
id_pl = u'hqc_meas.measure.monitors.text_monitor'
plugin = self.workbench.get_plugin(id_pl)
monitor = plugin.create_monitor(raw=True)
assert_equal(monitor._plugin, plugin)
assert_true(monitor.declaration)
assert_false(monitor.rules)
def test_monitor_set_state(self):
""" Test restoring the state of a monitor.
"""
id_pl = u'hqc_meas.measure.monitors.text_monitor'
plugin = self.workbench.get_plugin(id_pl)
monitor = plugin.create_monitor(raw=True)
monitor.measure_name = 'Test'
monitor.auto_show = False
entry = monitor._create_default_entry('test', 1)
entry.name = 'Custom'
entry.path = 'custom'
entry.formatting = 'This test n {root/test_loop}*{root/test2_loop}'
entry.depend_on = ['root/test_loop', 'root/test2_loop']
monitor.custom_entries.append(entry)
rule = FormatRule(name='Test',
suffixes=['loop', 'index'],
new_entry_suffix='progress',
new_entry_formatting='{index}/{loop}')
monitor.rules.append(rule)
monitor.database_modified({'value': ('root/test_loop', 10)})
monitor.database_modified({'value': ('root/test2_index', 1)})
monitor.database_modified({'value': ('root/test_index', 1)})
monitor.database_modified({'value': ('root/test2_loop', 10)})
state = monitor.get_state()
# Atom issue of _DictProxy
values = dict(monitor._database_values)
monitor_rebuilt = plugin.create_monitor(raw=True)
monitor_rebuilt.set_state(state, values)
assert_equal(monitor_rebuilt.measure_name, 'Test')
assert_false(monitor.auto_show)
assert_true(monitor_rebuilt.custom_entries)
c_entry = monitor_rebuilt.custom_entries[0]
assert_equal(c_entry.name, entry.name)
assert_equal(c_entry.path, entry.path)
assert_equal(c_entry.formatting, entry.formatting)
assert_equal(c_entry.depend_on, entry.depend_on)
assert_true(monitor_rebuilt.rules)
c_rule = monitor_rebuilt.rules[0]
assert_equal(c_rule.name, rule.name)
assert_equal(c_rule.suffixes, rule.suffixes)
assert_equal(c_rule.new_entry_suffix, rule.new_entry_suffix)
assert_equal(c_rule.new_entry_formatting, rule.new_entry_formatting)
assert_equal(len(monitor_rebuilt.displayed_entries), 3)
assert_equal(len(monitor_rebuilt.undisplayed_entries), 0)
assert_equal(len(monitor_rebuilt.hidden_entries), 4)
def test_add_rule_to_plugin(self):
""" Test adding a new rule definition to a plugin.
"""
id_pl = u'hqc_meas.measure.monitors.text_monitor'
plugin = self.workbench.get_plugin(id_pl)
monitor = plugin.create_monitor()
rule = FormatRule(name='Test',
suffixes=['loop', 'index'],
new_entry_suffix='progress',
new_entry_formatting='{index}/{loop}')
monitor.rules.append(rule)
monitor.add_rule_to_plugin('rule1')
assert_equal(len(plugin.rules.keys()), 2)
monitor.add_rule_to_plugin('Test')
assert_equal(len(plugin.rules.keys()), 3)
assert_in('Test', plugin.rules)
rule_conf = plugin.rules['Test']
assert_dict_equal(
rule_conf, {
'class_name': 'FormatRule',
'name': 'Test',
'hide_entries': 'True',
'suffixes': repr(['loop', 'index']),
'new_entry_suffix': 'progress',
'new_entry_formatting': '{index}/{loop}'
})
class TestWhileView(object):
def setup(self):
self.workbench = Workbench()
self.workbench.register(CoreManifest())
self.workbench.register(StateManifest())
self.workbench.register(PreferencesManifest())
self.workbench.register(TaskManagerManifest())
self.root = RootTask(should_stop=Event(), should_pause=Event())
self.task = WhileTask(task_name='Test', condition='rr')
self.root.children_task.append(self.task)
def teardown(self):
close_all_windows()
self.workbench.unregister(u'hqc_meas.task_manager')
self.workbench.unregister(u'hqc_meas.preferences')
self.workbench.unregister(u'hqc_meas.state')
self.workbench.unregister(u'enaml.workbench.core')
def test_view(self):
# Intantiate a view with no selected interface and select one after
window = enaml.widgets.api.Window()
core = self.workbench.get_plugin('enaml.workbench.core')
view = WhileView(window, task=self.task, core=core)
window.show()
process_app_events()
assert_equal(view.widgets()[1].text, 'rr')
view.widgets()[1].text = 'test'
process_app_events()
assert_equal(self.task.condition, 'test')
class TestAppPlugin(object):
"""Test the AppPlugin capabilities.
"""
def setup(self):
self.workbench = Workbench()
self.workbench.register(AppManifest())
self.workbench.register(CoreManifest())
self.workbench.register(ErrorsManifest())
def test_app_start_up(self):
"""Test running startups leading to new startup registrations.
"""
manifest = StartupContributor()
self.workbench.register(manifest)
plugin = self.workbench.get_plugin('ecpy.app')
plugin.run_app_startup(object())
assert manifest.called == ['test_nested.startup1', 'test.startup2',
'test_nested.startup2']
self.workbench.unregister('ecpy.app')
def test_closing(self):
"""Test that validation stops as soon as the event is rejected.
"""
manifest1 = ClosingContributor1()
manifest2 = ClosingContributor2()
self.workbench.register(manifest1)
self.workbench.register(manifest2)
window = FalseWindow(self.workbench)
plugin = self.workbench.get_plugin('ecpy.app')
ev = CloseEvent()
plugin.validate_closing(window, ev)
assert not ev.is_accepted()
assert not manifest2.called or not manifest1.called
manifest1.accept = True
manifest2.accept = True
plugin.validate_closing(window, ev)
assert ev.is_accepted()
assert manifest2.called
def test_app_cleanup(self):
"""Test running the app cleanup.
"""
manifest = ClosedContributor()
self.workbench.register(manifest)
plugin = self.workbench.get_plugin('ecpy.app')
plugin.run_app_cleanup()
assert manifest.called == ['test_nested.closed1', 'test.closed2',
'test_nested.closed2']
def test_app_startup_registation(self):
"""Test the AppStartup discovery.
"""
manifest = StartupContributor()
self.workbench.register(manifest)
plugin = self.workbench.get_plugin('ecpy.app')
assert len(plugin.startup.contributions) == 2
assert len(plugin._start_heap) == 2
self.workbench.unregister(manifest.id)
assert not plugin.startup.contributions
assert len(plugin._start_heap) == 0
def test_app_closing_registation(self):
"""Test the AppClosing discovery.
"""
manifest = ClosingContributor1()
self.workbench.register(manifest)
plugin = self.workbench.get_plugin('ecpy.app')
assert len(plugin.closing.contributions) == 1
self.workbench.unregister(manifest.id)
assert not plugin.closing.contributions
def test_app_closed_registation(self):
"""Test the AppClosed discovery.
"""
manifest = ClosedContributor()
self.workbench.register(manifest)
plugin = self.workbench.get_plugin('ecpy.app')
assert len(plugin.closed.contributions) == 2
assert len(plugin._clean_heap) == 2
self.workbench.unregister(manifest.id)
assert not plugin.closed.contributions
assert len(plugin._clean_heap) == 0
