def test_engine_status(execution_view, dialog_sleep):
"""Test te display of the engine status.
"""
execution_view.show()
process_app_events()
sleep(dialog_sleep)
item = execution_view.widget
en_stat = item.dock_widget().widgets()[-1]
assert not en_stat.visible
pl = item.workspace.plugin
pl.processor.engine = pl.create('engine', 'dummy')
pl.processor.engine.status = 'Stopped'
process_app_events()
assert en_stat.visible
assert en_stat.widgets()[1].text == 'Stopped'
meas = item.workspace.plugin.enqueued_measures.measures[0]
item.workspace.plugin.processor.running_measure = meas
item.workspace.plugin.processor.active = True
assert not en_stat.widgets()[2].enabled
assert en_stat.widgets()[2].text == 'Shut down'
def test_text_monitor_item(text_monitor_workbench, monitor, dialog_sleep):
"""Test that the dock item of the text monitor does display the right
entries.
"""
# Check only displayed entries are indeed shown.
monitor.handle_database_change(('added', 'root/test', 0))
monitor.handle_database_change(('added', 'root/simp/test', 0))
monitor.handle_database_change(('added', 'root/comp/index', 0))
monitor.move_entries('displayed', 'undisplayed',
[monitor.displayed_entries[0]])
w = DockItemTestingWindow(widget=TextMonitorItem(monitor=monitor))
w.show()
process_app_events()
f = w.widget.dock_widget()
assert (sorted([l.text for l in f.widgets()[::2]]) ==
sorted([e.name for e in monitor.displayed_entries]))
sleep(dialog_sleep)
e = sorted(monitor.displayed_entries, key=attrgetter('path'))[0]
e.name = 'new'
e.value = '1'
process_app_events()
assert f.widgets()[0].text == 'new'
assert f.widgets()[1].text == '1'
def test_show_monitors(execution_view, dialog_sleep):
"""Test restoring the monitor window.
"""
execution_view.show()
process_app_events()
sleep(dialog_sleep)
item = execution_view.widget
mon_btn = item.dock_widget().widgets()[5]
assert not mon_btn.enabled
with enaml.imports():
from ecpy.measure.workspace.monitors_window import MonitorsWindow
meas = item.workspace.plugin.enqueued_measures.measures[0]
mon_win = MonitorsWindow(item, measure=meas)
item.workspace.plugin.processor.monitors_window = mon_win
assert not mon_win.visible
mon_btn.clicked = True
process_app_events()
assert mon_win.visible
def test_selecting_profile_from_scratch(prof_plugin, process_and_sleep):
"""Test selecting a profile.
"""
d = ProfileSelectionDialog(plugin=prof_plugin)
d.show()
process_and_sleep()
d.profile = 'fp2'
assert not d.connection
assert not d.settings
process_and_sleep()
d.connection = 'false_connection1'
d.settings = 'false_settings1'
d.driver = 'tests.test.FalseDriver%s' % ('' if d.driver.endswith('2')
else 2)
assert not d.connection
assert not d.settings
process_and_sleep()
d.connection = 'false_connection'
d.settings = 'false_settings'
process_and_sleep()
d.central_widget().widgets()[-1].clicked = True
process_app_events()
assert d.result
def test_save_action(workspace, measure, windows):
"""Test that save action calls the proper commands.
"""
act = SaveAction(workspace=workspace,
action_context={'data': (None, None,
measure.root_task, None)})
with handle_dialog('reject'):
act.triggered = True
class CmdException(Exception):
def __init__(self, cmd, opts):
self.cmd = cmd
def invoke(self, cmd, opts, caller=None):
raise CmdException(cmd, opts)
from enaml.workbench.core.core_plugin import CorePlugin
old = CorePlugin.invoke_command
CorePlugin.invoke_command = invoke
try:
with pytest.raises(CmdException) as ex:
act.triggered = True
process_app_events()
assert ex.value.cmd == 'ecpy.app.errors.signal'
finally:
CorePlugin.invoke_command = old
def answer_dialog(dial):
selector = dial.selector
selector.selected_filter = 'Logic'
selector.selected_task = 'ecpy.WhileTask'
dial.config.task_name = 'Test'
process_app_events()
assert dial.config.ready
def test_stopping_measure_while_preprocessing(mode, processor,
measure_with_tools):
"""Test asking the processor to stop while is is running the pre-hooks.
The post-hooks should not be run.
"""
measure = measure_with_tools
if mode == 'between hooks':
# Will see the difference only in coverage
measure.move_tool('pre-hook', 0, 1)
processor.start_measure(measure)
pre_hook = measure.pre_hooks['dummy']
assert pre_hook.waiting.wait(5)
process_app_events()
processor.stop_measure(no_post_exec=True)
assert pre_hook.stop_called
pre_hook.go_on.set()
processor._thread.join()
process_app_events()
assert measure.status == 'INTERRUPTED'
m = processor.plugin.workbench.get_manifest('test.measure')
assert not m.find('runtime_dummy1').collected
assert not m.find('runtime_dummy2').collected
def test_collecting_registering_and_stopping(monkeypatch, workbench, windows):
"""Test basic behavior of PackaggesPlugin.
"""
patch_pkg(
monkeypatch,
[FalseEntryPoint(name="test", manifests=[Manifest1, Manifest2]), FalseEntryPoint(name="test2", manifests=[])],
)
app = workbench.get_plugin(APP_ID)
app.run_app_startup(object())
process_app_events()
plugin = workbench.get_plugin(PACKAGES_ID)
assert "test" in plugin.packages
assert "test2" in plugin.packages
assert "ecpy.test1" in plugin.packages["test"]
assert "ecpy.test2" in plugin.packages["test"]
assert (100, 0, "ecpy.test1") in plugin._registered
assert (0, 1, "ecpy.test2") in plugin._registered
assert workbench.get_plugin("ecpy.test1")
assert workbench.get_plugin("ecpy.test2")
workbench.unregister(PACKAGES_ID)
with pytest.raises(ValueError):
workbench.get_plugin("ecpy.test1")
with pytest.raises(ValueError):
workbench.get_plugin("ecpy.test2")
def test_running_forced_enqueued_measure(processor, measure_with_tools):
"""Test running a measure about which we know that checks are failing.
"""
measure = measure_with_tools
measure.forced_enqueued = True
measure.pre_hooks['dummy'].fail_check = True
processor.start_measure(measure_with_tools)
pre_hook = measure.pre_hooks['dummy']
assert pre_hook.waiting.wait(5)
process_app_events()
pre_hook.go_on.set()
wait_and_process(processor.engine.waiting.wait)
assert processor.engine.measure_force_enqueued
processor.engine.go_on.set()
post_hook = measure.post_hooks['dummy']
wait_and_process(post_hook.waiting.wait)
post_hook.go_on.set()
processor._thread.join()
process_app_events()
def test_stopping_processing_in_hook(processor, measure_with_tools):
"""Test stopping processing while running the main task..
"""
plugin = processor.plugin.workbench.get_plugin('ecpy.measure')
measure2 = Measure(plugin=plugin, root_task=RootTask(),
name='Dummy', id='002')
processor.plugin.enqueued_measures.add(measure2)
measure = measure_with_tools
processor.start_measure(measure)
pre_hook = measure.pre_hooks['dummy']
assert pre_hook.waiting.wait(5)
process_app_events()
processor.stop_processing(no_post_exec=True)
pre_hook.go_on.set()
def wait(timeout):
processor._thread.join(timeout)
return not processor._thread.is_alive()
wait_and_process(wait)
assert measure.status == 'INTERRUPTED'
m = processor.plugin.workbench.get_manifest('test.measure')
assert not m.find('runtime_dummy1').collected
assert not m.find('runtime_dummy2').collected
assert measure2.status == 'READY'
def test_stopping_measure_while_postprocessing(processor, measure_with_tools):
"""Test asking the processor to stop while is is running the post hooks.
"""
measure = measure_with_tools
measure.add_tool('post-hook', 'dummy2')
measure.post_hooks['dummy2'].fail_run = True
processor.start_measure(measure)
pre_hook = measure.pre_hooks['dummy']
assert pre_hook.waiting.wait(5)
process_app_events()
pre_hook.go_on.set()
wait_and_process(processor.engine.waiting.wait)
processor.engine.go_on.set()
post_hook = measure.post_hooks['dummy']
wait_and_process(post_hook.waiting.wait)
processor.stop_measure(force=True)
assert post_hook.stop_called
post_hook.go_on.set()
processor._thread.join()
process_app_events()
assert measure.status == 'INTERRUPTED'
m = processor.plugin.workbench.get_manifest('test.measure')
assert not m.find('runtime_dummy1').collected
assert not m.find('runtime_dummy2').collected
def test_profile_edition_dialog_cancel(prof_plugin, process_and_sleep,
profile_infos):
"""Test the dialog used to edit a profile.
"""
ed = ProfileEditionDialog(plugin=prof_plugin, profile_infos=profile_infos)
ed.show()
process_and_sleep()
ed_widgets = ed.central_widget().widgets()
ed_widget = ed_widgets[0]
nb = ed_widget.widgets()[5]
c_page, s_page = nb.pages()
# Delete a connection and open valiadtion window
c_page.page_widget().widgets()[3].clicked = True
c_page.page_widget().widgets()[4].clicked = True
# Delete a settings
s_page.page_widget().widgets()[4].clicked = True
process_and_sleep()
w = ed_widget._validator
assert len(ed_widget.connections) == 2
assert len(ed_widget.settings) == 2
ed_widgets[-2].clicked = True
process_app_events()
assert not ed.visible and not w.visible
assert len(profile_infos.connections) == 3
assert len(profile_infos.settings) == 3
def test_saving_as_template(windows, tmpdir, task_workbench, task,
monkeypatch):
"""Test saving a task as a template.
"""
from ecpy.tasks.utils import saving
monkeypatch.setattr(saving.TemplateViewer, 'exec_',
saving.TemplateViewer.show)
plugin = task_workbench.get_plugin('ecpy.tasks')
plugin.templates = {'test': ''}
def answer_dialog(dialog):
model = dialog._model
model.folder = str(tmpdir)
model.filename = 'test'
model.doc = 'This is a test'
dialog.show_result = True
assert model.accept_template_info(dialog)
core = task_workbench.get_plugin('enaml.workbench.core')
with handle_dialog('accept', answer_dialog):
core.invoke_command(CMD, dict(task=task, mode='template'))
get_window(Dialog).accept()
process_app_events()
path = str(tmpdir.join('test.task.ini'))
assert os.path.isfile(path)
config = ConfigObj(path)
assert config.initial_comment == ['# This is a test']
def test_logger_thread(app, logger):
"""Test the logger thread.
"""
queue = Queue()
handler = QueueHandler(queue)
logger.addHandler(handler)
logger.info('test')
logger.removeHandler(handler)
model = LogModel()
handler = GuiHandler(model)
logger.addHandler(handler)
thread = QueueLoggerThread(queue)
thread.start()
sleep(1)
queue.put(None)
thread.join(2)
process_app_events()
if thread.is_alive():
raise
assert model.text == 'test\n'
def test_pause2(self, app):
"""Test pausing and stopping the execution.
"""
def pause_and_stop(task, value):
"""Post a method stopping execution on event loop and pause.
"""
deferred_call(lambda t: t.root.should_stop.set(), task)
task.root.should_pause.set()
root = self.root
par = CheckTask(name='test', custom=pause_and_stop)
comp = ComplexTask(name='comp', stoppable=False,
parallel={'activated': True, 'pool': 'test'})
par2 = CheckTask(name='test2')
comp.add_child_task(0, par2)
par3 = CheckTask(name='test3')
for i, c in enumerate([par, comp, par3]):
root.add_child_task(i, c)
root.check()
t = threading.Thread(target=root.perform)
t.start()
sleep(0.1)
process_app_events()
t.join()
assert root.should_pause.is_set()
assert root.should_stop.is_set()
assert par.perform_called
assert not par2.perform_called
assert not par3.perform_called
def test_clear(execution_view, dialog_sleep):
"""Test clearing the enqueued measures.
"""
execution_view.show()
process_app_events()
sleep(dialog_sleep)
item = execution_view.widget
cl_btn = item.dock_widget().widgets()[4]
assert cl_btn.enabled
# Check disabled when running
meas = item.workspace.plugin.enqueued_measures.measures[0]
item.workspace.plugin.processor.running_measure = meas
item.workspace.plugin.processor.active = True
assert not cl_btn.enabled
item.workspace.plugin.processor.active = False
assert cl_btn.enabled
measures = item.workspace.plugin.enqueued_measures.measures
measures[0].status = 'COMPLETED'
measures[1].status = 'FAILED'
cl_btn.clicked = True
process_app_events()
assert not item.workspace.plugin.enqueued_measures.measures
assert not cl_btn.enabled
def test_browing_dialog_profiles_add(prof_plugin, process_and_sleep):
"""Test the browsing dialog page dedicated to explore the profiles.
"""
d = BrowsingDialog(plugin=prof_plugin)
nb = d.central_widget().widgets()[0]
nb.selected_tab = "profiles"
d.show()
process_and_sleep()
btn = nb.pages()[1].page_widget().widgets()[-2]
origin = prof_plugin.profiles[:]
with handle_dialog("reject", cls=ProfileEditionDialog):
btn.clicked = True
assert prof_plugin.profiles == origin
def handle(dial):
assert dial.creation
dial.profile_infos.id = "test"
dial.profile_infos.model = prof_plugin._profiles["fp1"].model
with handle_dialog("accept", handle, cls=ProfileEditionDialog):
btn.clicked = True
# Wait for file notification to be treated
sleep(1.0)
process_app_events()
assert "test" in prof_plugin.profiles
assert os.path.isfile(os.path.join(prof_plugin._profiles_folders[0], "test.instr.ini"))
def add_tool_1(dial):
widgets = dial.central_widget().widgets()
widgets[0].selected_item = 'Dummy'
process_app_events()
sleep(dialog_sleep)
widgets[-2].clicked = True
def test_stopping_measure_while_running_main(processor, measure_with_tools):
"""Test asking the processor to stop while is is running the main task.
The post-hooks should be run.
"""
measure = measure_with_tools
processor.start_measure(measure)
pre_hook = measure.pre_hooks['dummy']
assert pre_hook.waiting.wait(5)
process_app_events()
pre_hook.go_on.set()
wait_and_process(processor.engine.waiting.wait)
processor.stop_measure()
processor.engine.go_on.set()
post_hook = measure.post_hooks['dummy']
wait_and_process(post_hook.waiting.wait)
post_hook.go_on.set()
processor._thread.join()
process_app_events()
assert measure.status == 'INTERRUPTED'
m = processor.plugin.workbench.get_manifest('test.measure')
assert not m.find('runtime_dummy1').collected
assert not m.find('runtime_dummy2').collected
def test_running_measure_failing_post_hooks(processor, measure_with_tools):
"""Test running a measure whose post-hooks fail to execute.
"""
measure = measure_with_tools
measure_with_tools.post_hooks['dummy'].fail_run = True
processor.start_measure(measure_with_tools)
pre_hook = measure.pre_hooks['dummy']
assert pre_hook.waiting.wait(5)
process_app_events()
pre_hook.go_on.set()
wait_and_process(processor.engine.waiting.wait)
processor.engine.go_on.set()
post_hook = measure.post_hooks['dummy']
wait_and_process(post_hook.waiting.wait)
post_hook.go_on.set()
processor._thread.join()
process_app_events()
assert measure_with_tools.status == 'FAILED'
assert 'post-execution' in measure_with_tools.infos
m = processor.plugin.workbench.get_manifest('test.measure')
assert not m.find('runtime_dummy1').collected
assert not m.find('runtime_dummy2').collected
def run(measure):
t = Thread(target=processor._start_monitors, args=(measure,))
t.start()
while t.is_alive():
process_app_events()
sleep(0.001)
process_app_events()
sleep(dialog_sleep)
def test_sequence_config_view(windows):
"""Test the view of the base config.
"""
w = SequenceConfigView(model=SequenceConfig(sequence_doc='test',))
show_widget(w)
w.widgets()[1].text = 'test'
process_app_events()
assert w.model.ready
def test_starting_measure_no_measure_enqueued(processor):
"""Test starting next measure in the queue when no measures are enqueued.
"""
processor.start_measure(None)
assert processor.active
processor._thread.join()
process_app_events()
assert not processor.active
def test_entry_formatting():
"""Test that we can correctly format an entry.
"""
e = MonitoredEntry(name='test', formatting='{a} = {b}',
depend_on=['a', 'b'])
e.update(dict(a=1, b=2, c=3))
process_app_events()
assert e.value == '1 = 2'
def test_running_measure_whose_runtime_are_unavailable(processor, monkeypatch,
measure_with_tools):
"""Test running whose runtime dependencies are unavailable.
"""
monkeypatch.setattr(Flags, 'RUNTIME2_UNAVAILABLE', True)
processor.start_measure(measure_with_tools)
processor._thread.join()
process_app_events()
assert measure_with_tools.status == 'SKIPPED'
def wait_and_process(waiting_function):
"""Call a function which can timeout and process app events.
"""
i = 0
while not waiting_function(timeout=0.02):
process_app_events()
i += 1
if i > 5000:
assert False
process_app_events()
def test_pause1(self, app):
"""Test pausing and resuming the execution. (add instrs)
Tricky as only the main thread is allowed to resume.
"""
class Dummy(object):
"""False instrument checking that restarting does its job.
"""
owner = 'test'
called = 0
def finalize(self):
pass
def clear_cache(self):
self.called += 1
def pause(task, value):
"""Post a method restarting execution on event loop and pause.
"""
deferred_call(lambda t: t.root.should_pause.clear(), task)
task.root.should_pause.set()
root = self.root
dummy = Dummy()
root.resources['instrs']['test'] = dummy
par = CheckTask(name='test', custom=pause)
comp = ComplexTask(name='comp', stoppable=False,
parallel={'activated': True, 'pool': 'test'})
par2 = CheckTask(name='test2')
comp.add_child_task(0, par2)
par3 = CheckTask(name='test3')
for i, c in enumerate([par, comp, par3]):
root.add_child_task(i, c)
root.check()
t = threading.Thread(target=root.perform)
t.start()
sleep(0.1)
process_app_events()
t.join()
assert not root.should_pause.is_set()
assert not root.should_stop.is_set()
assert par.perform_called == 1
assert par2.perform_called == 1
assert par3.perform_called == 1
assert root.resumed.is_set()
assert dummy.called == 1
assert dummy.owner == ''
def test_plugin_lifecycle(instr_workbench):
"""Test the plugin lifecycle (initial registration and later on).
"""
instr_workbench.register(InstrContributor1())
# Test starting
p = instr_workbench.get_plugin("ecpy.instruments")
assert "tests" in p.users
assert "false_starter" in p.starters
assert "false_connection" in p.connections
assert "false_settings" in p.settings
assert "tests.test.FalseDriver" in p._drivers.contributions
for d in p._drivers.contributions.values():
assert d.valid
assert p.get_aliases("Dummy")
# Test later registration (incomplete as dynamic loading of driver is not
# fully implemented).
c2 = InstrContributor2()
instr_workbench.register(c2)
assert "tests_" in p.users
assert "false_starter_bis" in p.starters
assert "false_connection_bis" in p.connections
assert "false_settings_bis" in p.settings
# Test observation of profiles folders
shutil.copy(PROFILE_PATH, p._profiles_folders[0])
sleep(1.0)
process_app_events()
assert "fp" in p.profiles
os.remove(os.path.join(p._profiles_folders[0], "fp.instr.ini"))
sleep(1.0)
process_app_events()
assert "fp" not in p.profiles
# Test dynamic unregsitrations (same remark as above)
instr_workbench.unregister(c2.id)
assert "tests_" not in p.users
assert "false_starter_bis" not in p.starters
assert "false_connection_bis" not in p.connections
assert "false_settings_bis" not in p.settings
assert "Dummy" in p._manufacturers._manufacturers # dummy is an alias
# Stop
p.stop()
def answer_dialog(dial):
selector = dial.selector
qlist = selector.widgets()[-1]
qlist.selected_item = qlist.items[-1]
process_app_events()
sleep(dialog_sleep)
assert dial.config
selector.selected_task = '_dummy_'
process_app_events()
assert not dial.config
sleep(dialog_sleep)
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_running_measure_failing_pre_hooks(processor, measure_with_tools):
"""Test running a measure whose pre-hooks fail to execute.
"""
measure_with_tools.pre_hooks['dummy'].fail_run = True
processor.start_measure(measure_with_tools)
process_and_assert(getattr, (processor, 'active'))
pre_hook = measure_with_tools.pre_hooks['dummy']
process_and_assert(pre_hook.waiting.wait, (5, ))
process_app_events()
pre_hook.go_on.set()
process_and_join_thread(processor._thread)
assert measure_with_tools.status == 'FAILED'
assert 'pre-execution' in measure_with_tools.infos
m = processor.plugin.workbench.get_manifest('test.measure')
assert not m.find('runtime_dummy1').collected
assert not m.find('runtime_dummy2').collected
def test_rule_selection_for_loading(text_monitor_workbench, dialog_sleep):
"""Test using the dialog to select an existing config to load a task.
"""
p = text_monitor_workbench.get_plugin(PLUGIN_ID)
d = CreateRuleDialog(plugin=p)
d.show()
process_app_events()
sleep(dialog_sleep)
page = d.central_widget().widgets()[0].pages()[0]
page_content = page.page_widget().widgets()
# Select rule config
qlist = page_content[0]
qlist.selected_item = qlist.items[-1]
process_app_events()
assert page.rule == d.rule
sleep(dialog_sleep)
def test_stopping_processing_while_in_pause(processor, measure_with_tools):
"""Test stopping processing while in pause before starting main.
"""
plugin = processor.plugin.workbench.get_plugin('ecpy.measure')
measure2 = Measure(plugin=plugin,
root_task=RootTask(),
name='Dummy',
id='002')
processor.plugin.enqueued_measures.add(measure2)
def wait_on_state_paused(timeout):
return processor._state.wait(timeout, 'paused')
measure = measure_with_tools
processor.start_measure(measure)
pre_hook = measure.pre_hooks['dummy']
assert pre_hook.waiting.wait(5)
process_app_events()
processor.pause_measure()
pre_hook.accept_pause = False
pre_hook.go_on.set()
wait_and_process(wait_on_state_paused)
processor.stop_processing(no_post_exec=True)
sleep(0.2)
def wait(timeout):
processor._thread.join(timeout)
return not processor._thread.is_alive()
wait_and_process(wait)
assert measure.status == 'INTERRUPTED'
m = processor.plugin.workbench.get_manifest('test.measure')
assert not m.find('runtime_dummy1').collected
assert not m.find('runtime_dummy2').collected
assert measure2.status == 'READY'
def test_closing_measure(edition_view, monkeypatch, dialog_sleep):
"""Test closing the measure dock item.
"""
edition_view.show()
process_app_events()
sleep(dialog_sleep)
# Open the tools edition panel to check that we will properly close the
# it later
ed = edition_view.widget.dock_widget().widgets()[0]
btn = ed.widgets()[4]
btn.clicked = True
process_app_events()
# Monkeypatch question (handle_dialog does not work on it on windows)
with enaml.imports():
from ecpy.measure.workspace import measure_edition
monkeypatch.setattr(measure_edition, 'question', lambda *args: None)
edition_view.widget.proxy.on_closed()
edition_view.widget.measure.name = 'First'
process_app_events()
assert len(edition_view.area.dock_items()) == 2
sleep(dialog_sleep)
false_btn = namedtuple('FalseBtn', ['action'])
monkeypatch.setattr(measure_edition, 'question',
lambda *args: false_btn('reject'))
edition_view.widget.proxy.on_closed()
edition_view.widget.measure.name = 'Second'
process_app_events()
assert len(edition_view.area.dock_items()) == 2
sleep(dialog_sleep)
monkeypatch.setattr(measure_edition, 'question',
lambda *args: false_btn('accept'))
edition_view.widget.proxy.on_closed()
process_app_events()
assert len(edition_view.area.dock_items()) == 0
def test_visa_tcpip_socket(windows, process_and_sleep):
"""Test the visa tcpip connection.
"""
c = VisaTCPIP()
show_widget(c)
c.resource_class = 'SOCKET'
process_and_sleep()
c.widgets()[-4].text = '192.168.0.10'
c.widgets()[-2].text = '10000'
process_app_events()
c.widgets()[-1].checked = True
process_app_events()
assert c.gather_infos() == {
'interface_type': 'TCPIP',
'resource_class': 'SOCKET',
'host_address': '192.168.0.10',
'port': '10000',
'board': '0'
}
assemble_canonical_name(**c.gather_infos())
def test_profiles_observation(instr_workbench):
"""Test observing the profiles in the profile folders.
"""
instr_workbench.register(InstrContributor1())
# Test starting
p = instr_workbench.get_plugin('ecpy.instruments')
# Test observation of profiles folders
shutil.copy(PROFILE_PATH, p._profiles_folders[0])
sleep(1.0)
process_app_events()
assert 'fp' in p.profiles
os.remove(os.path.join(p._profiles_folders[0], 'fp.instr.ini'))
sleep(1.0)
process_app_events()
assert 'fp' not in p.profiles
def test_ending_with_no_tools(measure, windows, dialog_sleep):
"""Test adding/moving/removing tools.
"""
for m in list(measure.monitors):
measure.remove_tool('monitor', m)
item = ToolsEditorDockItem(measure=measure)
window = DockItemTestingWindow(widget=item)
window.show()
window.maximize()
process_app_events()
sleep(dialog_sleep)
nb = item.dock_widget().widgets()[0]
mon_ed = nb.pages()[1].page_widget().widgets()[0]
# Add a tool
def add_tool_1(dial):
widgets = dial.central_widget().widgets()
widgets[0].selected_item = 'Dummy'
process_app_events()
sleep(dialog_sleep)
with handle_dialog('accept', custom=add_tool_1):
mon_ed.widgets()[-4].clicked = True
assert 'dummy' in measure.monitors
# Move up and then down
mon_ed.selected_id = 'dummy'
assert not mon_ed.widgets()[-2].enabled
assert not mon_ed.widgets()[-1].enabled
# Remove dummy
mon_ed.widgets()[-3].clicked = True
process_app_events()
sleep(dialog_sleep)
assert 'dummy' not in measure.monitors
def test_gui_handler(app, logger, monkeypatch):
"""Test the gui handler.
"""
model = LogModel()
handler = GuiHandler(model)
logger.addHandler(handler)
logger.info('test')
process_app_events()
assert model.text == 'test\n'
model.clean_text()
logger.debug('test')
process_app_events()
assert model.text == 'DEBUG: test\n'
model.clean_text()
logger.warn('test')
process_app_events()
assert model.text == 'WARNING: test\n'
model.clean_text()
logger.error('test')
process_app_events()
assert model.text == 'ERROR: test\n'
model.clean_text()
logger.critical('test')
process_app_events()
answer = 'An error occured please check the log file for more details.\n'
assert model.text == answer
model.clean_text()
def err(record):
raise Exception
monkeypatch.setattr(handler, 'format', err)
logger.info('raise')
def test_profile_edition_dialog_ok(prof_plugin, process_and_sleep,
profile_infos):
"""Test the dialog used to edit a profile.
"""
# XXX need to test model selection
profile_infos.connections.clear()
profile_infos.settings.clear()
ed = ProfileEditionDialog(plugin=prof_plugin, profile_infos=profile_infos)
ed.show()
process_and_sleep()
ed_widgets = ed.central_widget().widgets()
ed_widget = ed_widgets[0]
nb = ed_widget.widgets()[5]
c_page, s_page = nb.pages()
# Add a connection
with handle_dialog(cls=ConnectionCreationDialog):
c_page.page_widget().widgets()[2].clicked = True
process_and_sleep()
# Add a settings
with handle_dialog(cls=SettingsCreationDialog):
s_page.page_widget().widgets()[2].clicked = True
process_and_sleep()
assert len(ed_widget.connections) == 1
assert len(ed_widget.settings) == 1
ed_widgets[-1].clicked = True
process_app_events()
assert len(profile_infos.connections) == 1
assert len(profile_infos.settings) == 1
def test_checks_display_warning(windows, dialog_sleep):
"""Test displaying checks that allow enqueuing.
"""
dial = ChecksDisplay(errors={
'test': 'dummy',
'internal': {
'rr': 'tt'
}
},
is_warning=True)
dial.show()
process_app_events()
sleep(dialog_sleep)
assert dial.central_widget().widgets()[-1].text == 'Enqueue'
dial.central_widget().widgets()[-1].clicked = True
process_app_events()
assert dial.result
def test_visa_usb(windows):
""" Test the visa usb connection.
"""
c = VisaUSB()
show_widget(c)
c.widgets()[-6].text = '0x00'
c.widgets()[-4].text = '0x01'
c.widgets()[-2].text = '0x02'
process_app_events()
c.widgets()[-1].checked = True
process_app_events()
assert c.gather_infos() == {
'interface_type': 'USB',
'resource_class': 'INSTR',
'manufacturer_id': '0x00',
'model_code': '0x01',
'serial_number': '0x02',
'usb_interface_number': '0',
'board': '0'
}
assemble_canonical_name(**c.gather_infos())
def test_stopping_processing(processor, measure_with_tools):
"""Test stopping processing while running the main task..
"""
plugin = processor.plugin.workbench.get_plugin('ecpy.measure')
measure2 = Measure(plugin=plugin,
root_task=RootTask(),
name='Dummy',
id='002')
processor.plugin.enqueued_measures.add(measure2)
measure = measure_with_tools
processor.start_measure(measure)
process_and_assert(getattr, (processor, 'active'))
pre_hook = measure.pre_hooks['dummy']
process_and_assert(pre_hook.waiting.wait, (5, ))
process_app_events()
pre_hook.go_on.set()
wait_and_process(processor.engine.waiting.wait)
processor.stop_processing(no_post_exec=True)
processor.engine.go_on.set()
def wait(timeout):
processor._thread.join(timeout)
return not processor._thread.is_alive()
wait_and_process(wait)
assert measure.status == 'INTERRUPTED'
m = processor.plugin.workbench.get_manifest('test.measure')
assert not m.find('runtime_dummy1').collected
assert not m.find('runtime_dummy2').collected
assert measure2.status == 'READY'
def test_process_news(monitor, database):
""" Test processing news coming from a database.
"""
rule = FormatRule(id='Test',
suffixes=['loop', 'index'],
new_entry_suffix='progress',
new_entry_formatting='{index}/{loop}',
hide_entries=False)
monitor.rules.append(rule)
database.observe('notifier', monitor.handle_database_entries_change)
database.set_value('root', 'test_loop', 10)
database.set_value('root', 'test_index', 1)
monitor.process_news(('root/test_index', 2))
process_app_events()
assert monitor.displayed_entries[0].value == '10'
assert monitor.displayed_entries[1].value == '2'
assert monitor.displayed_entries[2].value == '2/10'
monitor.updaters = {}
monitor.process_news(('root/test_index', 2))
process_app_events()
def test_measure_edition_dialog(workspace, measure, windows, monkeypatch,
dialog_sleep):
"""Test creating a measure edition dialog.
"""
dialog = MeasureEditorDialog(workspace=workspace, measure=measure)
dialog.show()
process_app_events()
sleep(dialog_sleep)
from ecpy.measure.workspace.workspace import MeasureSpace
def false_save(self, meas, *args, **kwargs):
false_save.called = 1
monkeypatch.setattr(MeasureSpace, 'save_measure', false_save)
btn = dialog.central_widget().widgets()[-1]
btn.clicked = True
process_app_events()
assert false_save.called
dialog.close()
def test_starting_measure_thread_not_dying(processor, measure):
"""Test starting but failing to stop the backgground thread.
"""
class FalseThread(object):
def __init__(self, processor):
self.state = processor._state
def is_alive(self):
return True
def join(self, timeout):
if not self.state.test('stop_processing'):
raise Exception()
processor._thread = FalseThread(processor)
core = processor.plugin.workbench.get_plugin('enaml.workbench.core')
core.invoke_command('ecpy.app.errors.enter_error_gathering')
processor.start_measure(None)
sleep(0.1)
process_app_events()
with pytest.raises(ErrorDialogException):
core.invoke_command('ecpy.app.errors.exit_error_gathering')
def test_workspace_lifecycle(workspace):
"""Test the workspace life cycle.
"""
process_app_events()
workbench = workspace.plugin.workbench
log = workbench.get_plugin('ecpy.app.logging')
# Check UI creation
assert workspace.content
assert workspace.dock_area
assert workbench.get_manifest('ecpy.measure.workspace.menus')
# Check log handling
assert 'ecpy.measure.workspace' in log.handler_ids
# Check engine handling
engine = workbench.get_manifest('test.measure').find('dummy_engine')
assert engine.workspace_contributing
# Check measure creation
assert len(workspace.plugin.edited_measures.measures) == 1
assert workspace.plugin.edited_measures.measures[0].monitors
# Check observance of engine selection.
workspace.plugin.selected_engine = ''
assert not engine.workspace_contributing
workspace.plugin.selected_engine = 'dummy'
assert engine.workspace_contributing
# Test stopping the workspace
core = workbench.get_plugin('enaml.workbench.core')
cmd = 'enaml.workbench.ui.close_workspace'
core.invoke_command(cmd, {'workspace': 'ecpy.measure.workspace'})
assert workspace.plugin.workspace is None
assert not engine.workspace_contributing
assert workbench.get_manifest('ecpy.measure.workspace.menus') is None
assert 'ecpy.measure.workspace' not in log.handler_ids
# Test restarting now that we have one edited measure.
cmd = 'enaml.workbench.ui.select_workspace'
core.invoke_command(cmd, {'workspace': 'ecpy.measure.workspace'})
assert len(workspace.plugin.edited_measures.measures) == 1
# Create a false monitors_window
workspace.plugin.processor.monitors_window = Window()
workspace.plugin.processor.monitors_window.show()
process_app_events()
# Stop again
core = workbench.get_plugin('enaml.workbench.core')
cmd = 'enaml.workbench.ui.close_workspace'
core.invoke_command(cmd, {'workspace': 'ecpy.measure.workspace'})
process_app_events()
assert not workspace.plugin.processor.monitors_window.visible
def test_pause2(self, app):
"""Test pausing and stopping the execution.
"""
def pause_and_stop(task, value):
"""Post a method stopping execution on event loop and pause.
"""
deferred_call(lambda t: t.root.should_stop.set(), task)
task.root.should_pause.set()
root = self.root
par = CheckTask(name='test', custom=pause_and_stop)
comp = ComplexTask(name='comp',
stoppable=False,
parallel={
'activated': True,
'pool': 'test'
})
par2 = CheckTask(name='test2')
comp.add_child_task(0, par2)
par3 = CheckTask(name='test3')
for i, c in enumerate([par, comp, par3]):
root.add_child_task(i, c)
root.check()
t = threading.Thread(target=root.perform)
t.start()
sleep(0.1)
process_app_events()
t.join()
assert root.should_pause.is_set()
assert root.should_stop.is_set()
assert par.perform_called
assert not par2.perform_called
assert not par3.perform_called
def test_connection_validation_window(prof_plugin, process_and_sleep,
profile_infos):
"""Test the window used to check that connection infos allows to open a
connection.
"""
ed = ProfileEditionDialog(plugin=prof_plugin, profile_infos=profile_infos)
ed.show()
process_and_sleep()
w = ConnectionValidationWindow(editor=ed.central_widget().widgets()[0])
w.show()
process_and_sleep()
# XXX need to select a driver
widgets = w.central_widget().widgets()
p = widgets[-3]
p.clicked = True
assert 'The connection was successfully established' in widgets[-2].text
# XXX add a test for failed connection test
widgets[-1].clicked = True
process_app_events()
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_loop_config_with_subtask(task_workbench, windows, dialog_sleep,
monkeypatch):
"""Test the loop config.
"""
plugin = task_workbench.get_plugin('ecpy.tasks')
config = LoopTaskConfig(manager=plugin,
task_class=plugin.get_task('ecpy.LoopTask'),
task_name='Test')
show_widget(LoopConfigView(config=config))
assert config.ready
sleep(dialog_sleep)
config.use_subtask = True
assert not config.ready
process_app_events()
sleep(dialog_sleep)
config.subtask = 'ecpy.BreakTask'
assert config.ready
process_app_events()
sleep(dialog_sleep)
def dummy(self):
self.ready = False
monkeypatch.setattr(type(config.subconfig), 'check_parameters', dummy)
config.task_name = 'Bis'
assert config.subconfig.task_name == 'Bis' # Check sync
assert not config.ready # Result from the monkeypatch
process_app_events()
sleep(dialog_sleep)
config.use_subtask = False
assert config.ready
process_app_events()
sleep(dialog_sleep)
config.use_subtask = True
config.subtask = 'ecpy.ContinueTask'
task = config.build_task()
assert task.name == 'Bis'
assert type(task.task).__name__ == 'ContinueTask'
def process_and_assert(test_func, args=(), kwargs={}, time=0.01, count=1000):
"""Process events and check test_func value.
"""
process_app_events()
counter = 0
while not test_func(*args, **kwargs):
sleep(time)
process_app_events()
if counter > count:
assert False
counter += 1
process_app_events()
def test_loop_config_with_subtask(task_workbench, windows, dialog_sleep):
"""Test the loop config.
"""
plugin = task_workbench.get_plugin('ecpy.tasks')
config = LoopTaskConfig(manager=plugin,
task_class=plugin.get_task('ecpy.LoopTask'),
task_name='Test')
show_widget(LoopConfigView(config=config))
assert config.ready
sleep(dialog_sleep)
config.use_subtask = True
assert not config.ready
process_app_events()
sleep(dialog_sleep)
config.subtask = 'ecpy.BreakTask'
assert config.ready
process_app_events()
sleep(dialog_sleep)
config.subconfig.task_name = ''
assert not config.ready
process_app_events()
sleep(dialog_sleep)
config.use_subtask = False
assert config.ready
process_app_events()
sleep(dialog_sleep)
config.use_subtask = True
config.subtask = 'ecpy.ContinueTask'
task = config.build_task()
assert task.name == 'Test'
assert type(task.task).__name__ == 'ContinueTask'
def test_measure_manipulations(execution_view, dialog_sleep):
"""Test moving/removing measure using editor
"""
execution_view.show()
process_app_events()
sleep(dialog_sleep)
item = execution_view.widget
ed = item.dock_widget().widgets()[0]
meas = item.workspace.plugin.enqueued_measures.measures
ed.operations['move'](0, 1)
process_app_events()
assert meas[0].name == 'dummy_test'
ed.operations['move'](0, 1)
process_app_events()
assert meas[1].name == 'dummy_test'
ed.operations['remove'](0)
process_app_events()
assert meas[0].name == 'dummy_test'
assert len(meas) == 1
def test_sync_name(edition_view, dialog_sleep):
"""Test the synchronisation between the measure name and widget.
"""
edition_view.show()
process_app_events()
sleep(dialog_sleep)
ed = edition_view.widget.dock_widget().widgets()[0]
meas = ed.measure
field = ed.widgets()[1]
meas.name = '__dummy'
process_app_events()
assert meas.name == field.text
field.text = 'dummy__'
process_app_events()
assert meas.name == field.text
def test_sync_id(edition_view, dialog_sleep):
"""Test the synchronisation between the measure id and widget.
"""
edition_view.show()
process_app_events()
sleep(dialog_sleep)
ed = edition_view.widget.dock_widget().widgets()[0]
meas = ed.measure
field = ed.widgets()[3]
meas.id = '101'
process_app_events()
assert meas.id == field.text
field.text = '202'
process_app_events()
assert meas.id == field.text
def test_tool_selector(windows, measure, dialog_sleep):
"""Selecting a new tool to add to a measure using the dedicated dialog.
"""
dial = ToolSelector(measure=measure, kind='pre-hook')
dial.show()
process_app_events()
widgets = dial.central_widget().widgets()
assert len(widgets[0].items) == (len(dial.measure.plugin.pre_hooks) -
len(dial.measure.pre_hooks))
widgets[0].selected_item = 'Dummy'
process_app_events()
sleep(dialog_sleep)
assert dial.selected_decl
assert widgets[-2].enabled
assert widgets[1].text
widgets[-1].clicked = True
process_app_events()
def test_continuous_processing(execution_view, dialog_sleep):
"""Test that the checkbox does reflect the underlying setting.
"""
execution_view.show()
process_app_events()
sleep(dialog_sleep)
item = execution_view.widget
ch_box = item.dock_widget().widgets()[3]
proc = item.workspace.plugin.processor
assert ch_box.checked == proc.continuous_processing
ch_box.checked = not proc.continuous_processing
process_app_events()
assert ch_box.checked == proc.continuous_processing
proc.continuous_processing = not ch_box.checked
process_app_events()
assert ch_box.checked == proc.continuous_processing
def test_content(content_workbench, windows, dialog_sleep):
"""Test creating the content of the workspace.
"""
w = content_workbench
ui = w.get_plugin('enaml.workbench.ui')
ui.show_window()
process_app_events()
sleep(dialog_sleep)
core = content_workbench.get_plugin('enaml.workbench.core')
cmd = 'enaml.workbench.ui.select_workspace'
core.invoke_command(cmd, {'workspace': 'ecpy.measure.workspace'})
process_app_events()
sleep(dialog_sleep)
pl = content_workbench.get_plugin('ecpy.measure')
pl.workspace.new_measure()
process_app_events()
sleep(dialog_sleep)
ui.close_window()
def test_app_window(workbench_and_tools):
"""Test that closing and closed handlers are called when trying to close
the app window.
"""
w, closing, closed = workbench_and_tools
ui = w.get_plugin('enaml.workbench.ui')
ui.show_window()
process_app_events()
ui.close_window()
process_app_events()
assert closing.called
assert ui.window.visible
closing.accept = True
ui.close_window()
process_app_events()
assert not ui.window.visible
assert closed.called
def test_swapping(windows, task_workbench, dialog_sleep):
"""Test moving a view between containers.
"""
task = RootTask()
view = RootTaskView(task=task,
core=task_workbench.get_plugin('enaml.workbench.core'))
subtask = ComplexTask(name='Test')
subview = view.view_for(subtask)
task.add_child_task(0, subtask)
cont = Container()
show_widget(cont)
view.set_parent(cont)
view.refresh()
process_app_events()
assert cont.children == [view]
sleep(dialog_sleep)
view.set_parent(None)
subview.set_parent(cont)
subview.refresh()
process_app_events()
assert cont.children == [subview]
sleep(dialog_sleep)
subview.set_parent(None)
view.set_parent(cont)
view.refresh()
process_app_events()
assert cont.children == [view]
assert subview.visible
sleep(dialog_sleep)
