def test_create_context(workbench, root, exopy_qtbot): """Test creating a context for a sequence. """ core = workbench.get_plugin('enaml.workbench.core') def select_context(exopy_qtbot, dial): """Select the sequence to build. """ obj_combo = dial.central_widget().widgets()[0] obj_combo.selected_item = 'Dummy' with handle_dialog(exopy_qtbot, 'accept', select_context): cmd = 'exopy.pulses.create_context' core.invoke_command(cmd, dict(root=root)) assert root.context is not None del root.context with handle_dialog(exopy_qtbot, 'reject'): cmd = 'exopy.pulses.create_context' core.invoke_command(cmd, dict(root=root)) assert root.context is None
def test_browing_dialog_profiles_delete(exopy_qtbot, prof_plugin, dialog_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() wait_for_window_displayed(exopy_qtbot, d) exopy_qtbot.wait(dialog_sleep) c = nb.pages()[0].page_widget() btn = c.widgets()[-1] c.p_id = 'fp1' print(prof_plugin._profiles) with handle_dialog(exopy_qtbot, 'reject', cls=MessageBox): btn.clicked = True assert 'fp1' in prof_plugin._profiles def handle(bot, dial): dial.buttons[0].was_clicked = True with handle_dialog(exopy_qtbot, 'accept', handle, cls=MessageBox): btn.clicked = True exopy_qtbot.wait(1000) def assert_profiles(): assert 'fp1' not in prof_plugin._profiles exopy_qtbot.wait_until(assert_profiles)
def test_create_sequence(root, workbench, exopy_qtbot, monkeypatch): """Test creating a sequence. """ core = workbench.get_plugin('enaml.workbench.core') def select_sequence(exopy_qtbot, dial): """Select the sequence to build. """ dial.selector.selected_sequence = 'exopy_pulses.BaseSequence' with handle_dialog(exopy_qtbot, 'accept', select_sequence): cmd = 'exopy.pulses.create_sequence' seq = core.invoke_command(cmd, dict(root=root)) assert seq is not None with handle_dialog(exopy_qtbot, 'reject'): cmd = 'exopy.pulses.create_sequence' seq = core.invoke_command(cmd, dict(root=root)) assert seq is None def raise_on_build(*args, **kwargs): raise Exception() from exopy_pulses.pulses.configs.base_config import SequenceConfig monkeypatch.setattr(SequenceConfig, 'build_sequence', raise_on_build) with handle_dialog(exopy_qtbot, 'accept', cls=ErrorsDialog, time=500): with handle_dialog(exopy_qtbot, 'accept', cls=BuilderView): cmd = 'exopy.pulses.create_sequence' seq = core.invoke_command(cmd, dict(root=root))
def test_report_command(err_workbench, exopy_qtbot): """Test generating an application errors report. """ core = err_workbench.get_plugin('enaml.workbench.core') with handle_dialog(exopy_qtbot): core.invoke_command('exopy.app.errors.report') with handle_dialog(exopy_qtbot): core.invoke_command('exopy.app.errors.report', dict(kind='error')) with handle_dialog(exopy_qtbot): core.invoke_command('exopy.app.errors.report', dict(kind='stupid'))
def test_handling_error_in_handlers(err_workbench, exopy_qtbot): """Test handling an error occuring in a specilaized handler. """ plugin = err_workbench.get_plugin(ERRORS_ID) def check_dialog(bot, dial): assert 'error' in dial.errors assert 'registering' not in dial.errors with handle_dialog(exopy_qtbot, handler=check_dialog): plugin.signal('registering') with handle_dialog(exopy_qtbot, handler=check_dialog): plugin.signal('registering', msg=FailedFormat())
def test_create_task2(exopy_qtbot, task_workbench, dialog_sleep): """Test handling user cancellation. """ core = task_workbench.get_plugin('enaml.workbench.core') def answer_dialog(exopy_qtbot, dial): selector = dial.selector qlist = selector.widgets()[-1] qlist.selected_item = qlist.items[-1] def assert_dial_config(): assert dial.config exopy_qtbot.wait_until(assert_dial_config) exopy_qtbot.wait(dialog_sleep) dial._choose_config('_dummy_') assert not dial.config exopy_qtbot.wait(dialog_sleep) with handle_dialog(exopy_qtbot, 'reject', answer_dialog): res = core.invoke_command('exopy.tasks.create_task') assert res is None
def test_enqueuing_fail_reload(workspace, monkeypatch, tmpdir, exopy_qtbot): """Test failing when reloading the measurement after saving. """ m = workspace.plugin.edited_measurements.measurements[0] m.root_task.default_path = str(tmpdir) from exopy.measurement.measurement import Measurement witness = [] @classmethod def r(cls, measurement_plugin, path, build_dep=None): witness.append(None) return None, {'r': 't'} monkeypatch.setattr(Measurement, 'load', r) with handle_dialog(exopy_qtbot): workspace.enqueue_measurement(m) # Check dependencies are cleaned up assert_dependencies_released(workspace, m) assert not workspace.plugin.enqueued_measurements.measurements assert witness
def handle_error_report(bot, dial): def answer_question(bot, dial): dial.buttons[1].was_clicked = True with handle_dialog(bot, 'reject', answer_question, cls=MessageBox): dial.central_widget().widgets()[-1].clicked = True
def test_save_action(exopy_qtbot, workspace, measurement): """Test that save action calls the proper commands. """ act = SaveAction(workspace=workspace, action_context={'data': (None, None, measurement.root_task, None)}) with handle_dialog(exopy_qtbot, '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 exopy_qtbot.wait(10) assert ex.value.cmd == 'exopy.app.errors.signal' finally: CorePlugin.invoke_command = old
def test_create_task2(exopy_qtbot, task_workbench, dialog_sleep, task_config): """Test handling user cancellation. """ core = task_workbench.get_plugin('enaml.workbench.core') def answer_dialog(exopy_qtbot, dial): selector = dial.selector qlist = selector.widgets()[-1] qlist.selected_item = qlist.items[-1] def assert_dial_config(): assert dial.config exopy_qtbot.wait_until(assert_dial_config) exopy_qtbot.wait(dialog_sleep) dial._choose_config('_dummy_') assert not dial.config exopy_qtbot.wait(dialog_sleep) root = RootTask() with handle_dialog(exopy_qtbot, 'reject', answer_dialog): res = core.invoke_command('exopy.tasks.create_task', dict(future_parent=root)) assert res is None
def test_save_action(exopy_qtbot, workspace, measurement): """Test that save action calls the proper commands. """ act = SaveAction( workspace=workspace, action_context={'data': (None, None, measurement.root_task, None)}) with handle_dialog(exopy_qtbot, '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 exopy_qtbot.wait(10) assert ex.value.cmd == 'exopy.app.errors.signal' finally: CorePlugin.invoke_command = old
def test_running_main_error_in_parser_modifying(exopy_qtbot, monkeypatch): """Test starting the main app but encountering an issue while adding arguments. """ import exopy.__main__ as em def false_iter(arg): class FalseEntryPoint(EntryPoint): def load(self, *args, **kwargs): def false_modifier(parser): raise Exception('Failed to add stupid argument to parser') return (false_modifier, 1) return [FalseEntryPoint('dummy', 'dummy')] monkeypatch.setattr(em, 'iter_entry_points', false_iter) def check_dialog(qtbot, dial): assert 'modifying' in dial.text with pytest.raises(SystemExit): with handle_dialog(exopy_qtbot, 'reject', check_dialog): main([])
def test_app_startup4(pref_workbench, tmpdir, exopy_qtbot): """Test app start-up when user request to reset app folder. """ manifest = PreferencesManifest() pref_workbench.register(manifest) app_dir = str(tmpdir.join('exopy')) # Add a app_directory.ini file. app_pref = os.path.join(exopy_path(), APP_PREFERENCES, APP_DIR_CONFIG) if not os.path.isfile(app_pref): conf = ConfigObj(encoding='utf8') conf.filename = app_pref conf['app_path'] = app_dir conf.write() # Start the app and fake a user answer. app = pref_workbench.get_plugin('exopy.app') class DummyArgs(object): reset_app_folder = True with handle_dialog(exopy_qtbot, handler=lambda bot, 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_app_startup1(pref_workbench, tmpdir, exopy_qtbot): """Test app start-up when no app_directory.ini exists. """ manifest = PreferencesManifest() pref_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(exopy_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 = pref_workbench.get_plugin('exopy.app') app_dir = str(tmpdir.join('exopy')) with handle_dialog(exopy_qtbot, handler=lambda bot, d: setattr(d, '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)
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)
def test_enqueueing_abort_warning(workspace, monkeypatch, tmpdir, exopy_qtbot): """Test aborting enqueueing because some checks raised warnings. """ m = workspace.plugin.edited_measurements.measurements[0] m.root_task.default_path = str(tmpdir) from exopy.measurement.measurement import Measurement witness = [] def check(*args, **kwargs): witness.append(None) return True, {'r': {'t': 's'}} monkeypatch.setattr(Measurement, 'run_checks', check) with handle_dialog(exopy_qtbot, 'reject'): workspace.enqueue_measurement(m) # Check dependencies are cleaned up assert_dependencies_released(workspace, m) assert not workspace.plugin.enqueued_measurements.measurements assert witness
def test_signal_command_with_unknown(err_workbench, exopy_qtbot): """Test the signal command with a stupid kind of error. """ core = err_workbench.get_plugin('enaml.workbench.core') with handle_dialog(exopy_qtbot): core.invoke_command('exopy.app.errors.signal', {'kind': 'stupid', 'msg': None}) with handle_dialog(exopy_qtbot): fail = FailedFormat() core.invoke_command('exopy.app.errors.signal', {'kind': 'stupid', 'msg': fail}) assert getattr(fail, 'called', None)
def test_saving_as_template(exopy_qtbot, tmpdir, task_workbench, task, monkeypatch): """Test saving a task as a template. """ from exopy.tasks.utils import saving monkeypatch.setattr(saving.TemplateViewer, 'exec_', saving.TemplateViewer.show) plugin = task_workbench.get_plugin('exopy.tasks') plugin.templates = {'test': ''} def answer_dialog(bot, 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(exopy_qtbot, 'accept', answer_dialog): core.invoke_command(CMD, dict(task=task, mode='template')) w = get_window(exopy_qtbot, Dialog) w.accept() wait_for_destruction(exopy_qtbot, w) 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_driver_validation_error_handler(exopy_qtbot, instr_workbench): """Test the error handler dedicated to driver validation issues. """ core = instr_workbench.get_plugin('enaml.workbench.core') p = instr_workbench.get_plugin('exopy.instruments') d = DriverInfos(starter='starter', connections={ 'c1': {}, 'c2': {} }, settings={ 's2': {}, 's3': {} }) cmd = 'exopy.app.errors.signal' def check_dialog(bot, dial): w = dial.errors['exopy.driver-validation'] assert 'd' in w.errors for err in ('starter', 'connections', 'settings'): assert err in w.errors['d'] with handle_dialog(exopy_qtbot, 'accept', check_dialog): core.invoke_command(cmd, { 'kind': 'exopy.driver-validation', 'details': { 'd': d.validate(p)[1] } })
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)
def test_select_instrument(instr_task_workbench, instr_view, exopy_qtbot): """Test selecting an instrument from the view. """ tool_btn = instr_view.widgets()[-1].widgets()[-1] selec = ('fp1', 'tasks.test.FalseDriver', 'false_connection', 'false_settings') instr_view.task.selected_instrument = selec with handle_dialog(exopy_qtbot, 'reject'): tool_btn.clicked = True assert instr_view.task.selected_instrument == selec with handle_dialog(exopy_qtbot, 'accept'): tool_btn.clicked = True assert instr_view.task.selected_instrument == selec
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)
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_saving_as_template_cancelled(exopy_qtbot, task_workbench, task): """Test saving a task as a template : fail to save. """ core = task_workbench.get_plugin('enaml.workbench.core') with handle_dialog(exopy_qtbot, 'reject'): val = core.invoke_command(CMD, dict(task=task, mode='template')) assert val is None
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)
def test_open_browser_command(exopy_qtbot, prof_plugin): """Test opening the browsing window. """ with enaml.imports(): from enaml.workbench.ui.ui_manifest import UIManifest prof_plugin.workbench.register(UIManifest()) core = prof_plugin.workbench.get_plugin('enaml.workbench.core') with handle_dialog(exopy_qtbot): core.invoke_command('exopy.instruments.open_browser')
def test_profile_edition_dialog_ok(prof_plugin, dialog_sleep, exopy_qtbot, 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() wait_for_window_displayed(exopy_qtbot, ed) exopy_qtbot.wait(dialog_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(exopy_qtbot, cls=ConnectionCreationDialog): c_page.page_widget().widgets()[2].clicked = True exopy_qtbot.wait(10 + dialog_sleep) # Add a settings with handle_dialog(exopy_qtbot, cls=SettingsCreationDialog): s_page.page_widget().widgets()[2].clicked = True exopy_qtbot.wait(10 + dialog_sleep) assert len(ed_widget.connections) == 1 assert len(ed_widget.settings) == 1 ed_widgets[-1].clicked = True def assert_cn_st(): assert len(profile_infos.connections) == 1 assert len(profile_infos.settings) == 1 exopy_qtbot.wait_until(assert_cn_st)
def test_measurement_view(measurement, exopy_qtbot, dialog_sleep, monkeypatch, workspace): """Test that the displayed buttons do reflect the state of the measurement. """ measurement.status = 'READY' view = MeasView(model=measurement) w = ContainerTestingWindow(widget=view) w.show() wait_for_window_displayed(exopy_qtbot, w) exopy_qtbot.wait(dialog_sleep) assert view.widgets()[2].enabled # cd1 inserted its children before itself def test_state(bot, dial): assert dial.measurement.status == 'EDITING' with handle_dialog(exopy_qtbot, 'reject', handler=test_state): view.widgets()[2].clicked = True assert view.widgets()[-1].enabled measurement.plugin.processor.active = True def assert_enabled(): assert not view.widgets()[-1].enabled exopy_qtbot.wait_until(assert_enabled) measurement.plugin.processor.active = False from exopy.measurement.workspace.workspace import MeasurementSpace spy = CallSpy() monkeypatch.setattr(MeasurementSpace, 'process_single_measurement', spy) view.widgets()[-1].clicked = True assert spy.called measurement.status = 'RUNNING' def assert_widgets(): assert len(view.widgets()) == 2 exopy_qtbot.wait_until(assert_widgets) measurement.status = 'COMPLETED' def assert_widgets(): assert len(view.widgets()) == 3 exopy_qtbot.wait_until(assert_widgets) spy = CallSpy() monkeypatch.setattr(MeasurementSpace, 'reenqueue_measurement', spy) view.widgets()[-1].clicked = True assert view.widgets()[1].text == 'COMPLETED'
def test_running_main_error_in_parsing(exopy_qtbot): """Test starting the main app but encountering an issue while adding arguments. """ def check_dialog(qtbot, dial): assert 'cmd' in dial.text with pytest.raises(SystemExit): with handle_dialog(exopy_qtbot, 'reject', check_dialog): main(['dummy'])
def test_select_instrument_profile_command(exopy_qtbot, prof_plugin): """Test selecting an instrument profile. """ core = prof_plugin.workbench.get_plugin('enaml.workbench.core') with handle_dialog(exopy_qtbot, 'reject'): res = core.invoke_command('exopy.instruments.select_instrument') assert res is None with handle_dialog(exopy_qtbot, 'accept'): res = core.invoke_command( 'exopy.instruments.select_instrument', dict(profile='fp1', driver='instruments.test.FalseDriver', connection='false_connection3', settings='false_settings3')) assert res == ('fp1', 'instruments.test.FalseDriver', 'false_connection3', 'false_settings3')
def test_signal_command_with_unknown(err_workbench, exopy_qtbot): """Test the signal command with a stupid kind of error. """ core = err_workbench.get_plugin('enaml.workbench.core') with handle_dialog(exopy_qtbot): core.invoke_command('exopy.app.errors.signal', { 'kind': 'stupid', 'msg': None }) with handle_dialog(exopy_qtbot): fail = FailedFormat() core.invoke_command('exopy.app.errors.signal', { 'kind': 'stupid', 'msg': fail }) assert getattr(fail, 'called', None)
def test_enqueueing_fail_checks(workspace, exopy_qtbot): """Test enqueueing a measurement not passing the checks. """ m = workspace.plugin.edited_measurements.measurements[0] with handle_dialog(exopy_qtbot, 'reject'): workspace.enqueue_measurement(m) assert not workspace.plugin.enqueued_measurements.measurements # Check dependencies are cleaned up assert_dependencies_released(workspace, m)
def test_browing_dialog_profiles_edit(exopy_qtbot, prof_plugin, dialog_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() wait_for_window_displayed(exopy_qtbot, d) exopy_qtbot.wait(dialog_sleep) c = nb.pages()[0].page_widget() btn = c.widgets()[-2] c.p_id = 'fp1' manu = prof_plugin._manufacturers._manufacturers['Dummy'] model = manu._series['dumb']._models['002'] def handle(bot, dial): dial.profile_infos.model = model with handle_dialog(exopy_qtbot, 'reject', handle, cls=ProfileEditionDialog): btn.clicked = True assert prof_plugin._profiles['fp1'].model != model def handle(bot, dial): assert not dial.creation dial.profile_infos.model = model dial.central_widget().widgets()[0].sync() with handle_dialog(exopy_qtbot, 'accept', handle, cls=ProfileEditionDialog): btn.clicked = True assert prof_plugin._profiles['fp1'].model == model assert (ConfigObj(prof_plugin._profiles['fp1'].path)['model_id'] == 'Dummy.dumb.002')
def test_display_current_log(self, app_dir, exopy_qtbot): """Test the log display window """ cmd_args = CMDArgs() cmd_args.nocapture = True app = self.workbench.get_plugin('exopy.app') app.run_app_startup(cmd_args) core = self.workbench.get_plugin(u'enaml.workbench.core') with handle_dialog(exopy_qtbot): core.invoke_command('exopy.app.logging.display_current_log', {}, self)
def test_browing_dialog_profiles_edit(exopy_qtbot, prof_plugin, dialog_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() wait_for_window_displayed(exopy_qtbot, d) exopy_qtbot.wait(dialog_sleep) c = nb.pages()[0].page_widget() btn = c.widgets()[-2] c.p_id = 'fp1' manu = prof_plugin._manufacturers._manufacturers['Dummy'] model = manu._series['dumb']._models['002'] def handle(bot, dial): dial.profile_infos.model = model with handle_dialog(exopy_qtbot, 'reject', handle, cls=ProfileEditionDialog): btn.clicked = True assert prof_plugin._profiles['fp1'].model != model def handle(bot, dial): assert not dial.creation dial.profile_infos.model = model dial.central_widget().widgets()[0].sync() with handle_dialog(exopy_qtbot, 'accept', handle, cls=ProfileEditionDialog): btn.clicked = True assert prof_plugin._profiles['fp1'].model == model assert (ConfigObj( prof_plugin._profiles['fp1'].path)['model_id'] == 'Dummy.dumb.002')
def test_browing_dialog_profiles_add(exopy_qtbot, prof_plugin, dialog_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() wait_for_window_displayed(exopy_qtbot, d) exopy_qtbot.wait(dialog_sleep) btn = nb.pages()[0].page_widget().widgets()[-3] origin = prof_plugin.profiles[:] with handle_dialog(exopy_qtbot, 'reject', cls=ProfileEditionDialog): btn.clicked = True assert prof_plugin.profiles == origin def handle(bot, dial): assert dial.creation dial.profile_infos.id = 'test' dial.profile_infos.model = prof_plugin._profiles['fp1'].model with handle_dialog(exopy_qtbot, 'accept', handle, cls=ProfileEditionDialog): btn.clicked = True # Wait for file notification to be treated exopy_qtbot.wait(1000) def assert_profiles(): assert 'test' in prof_plugin.profiles assert os.path.isfile(os.path.join(prof_plugin._profiles_folders[0], 'test.instr.ini')) exopy_qtbot.wait_until(assert_profiles)
def test_gathering_mode(err_workbench, exopy_qtbot): """Test gathering multiple errors. """ core = err_workbench.get_plugin('enaml.workbench.core') core.invoke_command('exopy.app.errors.enter_error_gathering') core.invoke_command('exopy.app.errors.signal', {'kind': 'stupid', 'msg': None}) with pytest.raises(AssertionError): get_window(exopy_qtbot) with handle_dialog(exopy_qtbot): core.invoke_command('exopy.app.errors.exit_error_gathering')
def test_enqueueing_fail_runtime(workspace, monkeypatch, exopy_qtbot): """Test enqueueing a measurement for which runtimes cannot be collected. """ m = workspace.plugin.edited_measurements.measurements[0] m.add_tool('pre-hook', 'dummy') monkeypatch.setattr(Flags, 'RUNTIME2_FAIL_COLLECT', True) with handle_dialog(exopy_qtbot): workspace.enqueue_measurement(m) assert not workspace.plugin.enqueued_measurements.measurements # Check dependencies are cleaned up assert_dependencies_released(workspace, m) w = workspace.plugin.workbench d = w.get_manifest('test.measurement') assert d.find('runtime_dummy2').called
def test_unmet_requirement(monkeypatch, pack_workbench, exopy_qtbot): """Test loading an extension package for which some requirements are not met. """ patch_pkg(monkeypatch, [FalseEntryPoint(name='test', missing_require=True), FalseEntryPoint(name='test2', manifests=[])]) app = pack_workbench.get_plugin(APP_ID) with handle_dialog(exopy_qtbot): app.run_app_startup(object()) plugin = pack_workbench.get_plugin(PACKAGES_ID) assert 'test' in plugin.packages assert 'test2' in plugin.packages assert 'load' in plugin.packages['test'] assert not plugin._registered
def test_wrong_return_type(monkeypatch, pack_workbench, exopy_qtbot): """Test handling a wrong return type from the callable returned by load. """ patch_pkg(monkeypatch, [FalseEntryPoint(name='test', manifests=Manifest1), FalseEntryPoint(name='test2', manifests=[])]) app = pack_workbench.get_plugin(APP_ID) with handle_dialog(exopy_qtbot): app.run_app_startup(object()) plugin = pack_workbench.get_plugin(PACKAGES_ID) assert 'test' in plugin.packages assert 'test2' in plugin.packages assert 'list' in plugin.packages['test'] assert not plugin._registered
def test_non_manifest(monkeypatch, pack_workbench, exopy_qtbot): """Test handling a non PluginManifest in the list of manifests. """ patch_pkg(monkeypatch, [FalseEntryPoint(name='test', manifests=[Manifest1, object]), FalseEntryPoint(name='test2', manifests=[])]) app = pack_workbench.get_plugin(APP_ID) with handle_dialog(exopy_qtbot): app.run_app_startup(object()) plugin = pack_workbench.get_plugin(PACKAGES_ID) assert 'test' in plugin.packages assert 'test2' in plugin.packages assert 'PluginManifests' in plugin.packages['test'] assert not plugin._registered
def test_registering_issue(monkeypatch, pack_workbench, exopy_qtbot): """Test handling an error when registering a manifest. """ patch_pkg(monkeypatch, [FalseEntryPoint(name='test', manifests=[Manifest1, Manifest1]), FalseEntryPoint(name='test2', manifests=[])]) app = pack_workbench.get_plugin(APP_ID) with handle_dialog(exopy_qtbot): app.run_app_startup(object()) plugin = pack_workbench.get_plugin(PACKAGES_ID) assert 'test' in plugin.packages assert 'test2' in plugin.packages assert 'exopy.test1' in plugin.packages['test'] assert len(plugin.packages['test']) == 1