def __execute_test_save(self, project_dir): self.addCleanup(lambda: DeleteDirectoryIfExisting(project_dir)) DeleteDirectoryIfExisting(project_dir) # remove potential leftovers controller = PluginController() with patch.object(controller._project_path_handler, 'GetSavePath', return_value=project_dir) as patch_fct: controller._Save() self.assertTrue(project_dir.is_dir()) self.assertGreater(len(listdir(project_dir)), 0) # make sure sth was created
def test_Open_aborted(self): controller = PluginController() with patch.object(controller._project_path_handler, 'GetOpenPath', return_value=Path(".")) as patch_fct_get_open_path: with patch.object(controller._project_manager, 'OpenProject', return_value=True) as patch_fct_open_proj: with self.assertLogs('kratos_salome_plugin.gui.plugin_controller', level='INFO') as cm: controller._Open() self.assertEqual(len(cm.output), 1) self.assertEqual(cm.output[0], 'INFO:kratos_salome_plugin.gui.plugin_controller:Opening was aborted') self.assertEqual(patch_fct_get_open_path.call_count, 1) self.assertEqual(patch_fct_open_proj.call_count, 0)
def test_Open_invalid_folder(self): controller = PluginController() with patch(_QFileDialog_patch+'getExistingDirectory', return_value=str("random_folder")) as patch_fct: with patch.object(controller._project_manager, 'OpenProject', return_value=True) as patch_fct_open_proj: with self.assertLogs('kratos_salome_plugin.gui.plugin_controller', level='INFO') as cm: controller._Open() self.assertEqual(len(cm.output), 1) self.assertEqual(cm.output[0], 'WARNING:kratos_salome_plugin.gui.plugin_controller:User input error while opening project: Invalid project folder selected, must end with ".ksp"!') self.assertEqual(patch_fct.call_count, 1) self.assertEqual(patch_fct_open_proj.call_count, 0)
def test_Open_failed(self): controller = PluginController() project_dir = Path("controller_open_project_failed.ksp") with patch.object(controller._project_path_handler, 'GetOpenPath', return_value=project_dir) as patch_fct_get_open_path: with patch.object(controller._project_manager, 'OpenProject', return_value=False) as patch_fct_open_proj: with self.assertLogs('kratos_salome_plugin.gui.plugin_controller', level='INFO') as cm: controller._Open() self.assertEqual(len(cm.output), 1) self.assertEqual(cm.output[0], 'CRITICAL:kratos_salome_plugin.gui.plugin_controller:Failed to open project from "{}"!'.format(project_dir)) self.assertEqual(patch_fct_get_open_path.call_count, 1) self.assertEqual(patch_fct_open_proj.call_count, 1)
def test_New(self): controller = PluginController() controller._previous_save_path = Path("some/path") initial_project_manager = controller._project_manager initial_project_path_handler = controller._project_path_handler controller._New() # make sure things were cleaned properly self.assertIsNone(controller._previous_save_path) self.assertIsNot(initial_project_manager, controller._project_manager) self.assertIsNot(initial_project_path_handler, controller._project_path_handler)
def test_Close(self): controller = PluginController() controller._main_window.ShowOnTop() self.assertFalse(controller._main_window.isMinimized()) self.assertTrue(controller._main_window.isVisible()) self.assertFalse(controller._main_window.isHidden()) self.assertEqual(controller._main_window.windowState(), Qt.WindowNoState) controller._Close() self.assertFalse(controller._main_window.isMinimized()) self.assertFalse(controller._main_window.isVisible()) self.assertTrue(controller._main_window.isHidden()) self.assertEqual(controller._main_window.windowState(), Qt.WindowNoState)
def test_main_window_active_window(self): # setting initial state active_window.ACTIVE_WINDOW = None controller = PluginController() self.assertIs(active_window.ACTIVE_WINDOW, controller._main_window)
def test_SaveAndReOpen(self): # imported here due to patching issues from kratos_salome_plugin.salome_study_utilities import GetNumberOfObjectsInStudy, ResetStudy project_dir = Path("controller_save_open_project_salome.ksp") initial_num_objs = GetNumberOfObjectsInStudy() self.__execute_test_save(project_dir) ResetStudy() controller = PluginController() with patch.object(controller._project_path_handler, 'GetOpenPath', return_value=project_dir) as patch_fct: controller._Open() self.assertEqual(GetNumberOfObjectsInStudy(), initial_num_objs)
def test_main_window_reopen(self): controller = PluginController() orig_obj = controller._main_window controller._main_window.close() controller._main_window.ShowOnTop() self.assertIs(orig_obj, controller._main_window)
def test_Save_failed(self, mock_save_study, mock_version): project_dir = Path("controller_save_project_failed.ksp") controller = PluginController() controller._previous_save_path = project_dir with patch.object(controller._project_path_handler, 'GetSavePath', return_value=project_dir) as patch_fct_get_save_path: with patch.object(controller._project_manager, 'SaveProject', return_value=False) as patch_fct_save_proj: with self.assertLogs('kratos_salome_plugin.gui.plugin_controller', level='INFO') as cm: controller._Save() self.assertEqual(len(cm.output), 2) self.assertEqual(cm.output[0], 'INFO:kratos_salome_plugin.gui.plugin_controller:Saving project with previous save path ...') self.assertEqual(cm.output[1], 'CRITICAL:kratos_salome_plugin.gui.plugin_controller:Failed to save project under "{}"!'.format(project_dir)) self.assertEqual(patch_fct_get_save_path.call_count, 0) self.assertEqual(patch_fct_save_proj.call_count, 1) self.assertFalse(project_dir.is_dir()) self.assertEqual(controller._previous_save_path, project_dir)
def test_Save_aborted(self, mock_save_study, mock_version): project_dir = Path("controller_save_project_aborted.ksp") controller = PluginController() self.assertIsNone(controller._previous_save_path) with patch.object(controller._project_manager, 'SaveProject') as patch_fct_save_project: with patch.object(controller._main_window, 'StatusBarWarning') as patch_fct_status_bar: with patch(_QFileDialog_patch+'getSaveFileName', return_value=("",0)) as patch_fct: with self.assertLogs('kratos_salome_plugin.gui.plugin_controller', level='INFO') as cm: controller._Save() self.assertEqual(len(cm.output), 2) self.assertEqual(cm.output[0], 'INFO:kratos_salome_plugin.gui.plugin_controller:Saving project as ...') self.assertEqual(cm.output[1], 'INFO:kratos_salome_plugin.gui.plugin_controller:Saving was aborted') self.assertEqual(patch_fct_save_project.call_count, 0) self.assertEqual(patch_fct_status_bar.call_count, 1) self.assertEqual(patch_fct.call_count, 1) self.assertFalse(project_dir.is_dir()) self.assertIsNone(controller._previous_save_path)
def test_SaveAs(self, mock_save_study, mock_version): project_dir = Path("controller_save_project_as.ksp") self.addCleanup(lambda: DeleteDirectoryIfExisting(project_dir)) DeleteDirectoryIfExisting(project_dir) # remove potential leftovers controller = PluginController() self.assertIsNone(controller._previous_save_path) with patch.object(controller._main_window, 'StatusBarInfo') as patch_fct_status_bar: with patch.object(controller._project_path_handler, 'GetSavePath', return_value=project_dir) as patch_fct: with self.assertLogs('kratos_salome_plugin.gui.plugin_controller', level='INFO') as cm: controller._SaveAs() self.assertEqual(len(cm.output), 2) self.assertEqual(cm.output[0], 'INFO:kratos_salome_plugin.gui.plugin_controller:Saving project as ...') self.assertEqual(cm.output[1], 'INFO:kratos_salome_plugin.gui.plugin_controller:Saved project under "{}"'.format(project_dir)) self.assertEqual(patch_fct_status_bar.call_count, 1) self.assertEqual(patch_fct.call_count, 1) self.assertTrue(project_dir.is_dir()) num_files_after_first_save = len(listdir(project_dir)) self.assertGreater(num_files_after_first_save, 0) self.assertEqual(controller._previous_save_path, project_dir) # calling it a second time should ask again for the save-path controller._SaveAs() self.assertEqual(patch_fct_status_bar.call_count, 2) self.assertEqual(patch_fct.call_count, 2) self.assertTrue(project_dir.is_dir()) self.assertEqual(num_files_after_first_save, len(listdir(project_dir))) # make sure not more files are created self.assertEqual(controller._previous_save_path, project_dir)
def test_Save_second_save(self, mock_save_study, mock_version): project_dir = Path("controller_save_project_second.ksp") self.addCleanup(lambda: DeleteDirectoryIfExisting(project_dir)) DeleteDirectoryIfExisting(project_dir) # remove potential leftovers controller = PluginController() controller._previous_save_path = project_dir with patch.object(controller._main_window, 'StatusBarInfo') as patch_fct_status_bar: with patch.object(controller._project_path_handler, 'GetSavePath', return_value=project_dir) as patch_fct: with self.assertLogs('kratos_salome_plugin.gui.plugin_controller', level='INFO') as cm: controller._Save() self.assertEqual(len(cm.output), 2) self.assertEqual(cm.output[0], 'INFO:kratos_salome_plugin.gui.plugin_controller:Saving project with previous save path ...') self.assertEqual(cm.output[1], 'INFO:kratos_salome_plugin.gui.plugin_controller:Saved project under "{}"'.format(project_dir)) self.assertEqual(patch_fct_status_bar.call_count, 1) self.assertEqual(patch_fct.call_count, 0) # should not be called as previous save path is used self.assertTrue(project_dir.is_dir()) self.assertEqual(controller._previous_save_path, project_dir)
def test_kratos_load_application(self): with patch.object(PluginController, '_LoadApplication') as patch_fct: controller = PluginController() controller._main_window.actionLoad_Application.trigger() self.assertEqual(patch_fct.call_count, 1)
def test_kratos_groups(self): with patch.object(PluginController, '_Groups') as patch_fct: controller = PluginController() controller._main_window.actionGroups.trigger() self.assertEqual(patch_fct.call_count, 1)
def test_file_close(self): with patch.object(PluginController, '_Close') as patch_fct: controller = PluginController() controller._main_window.actionClose.trigger() self.assertEqual(patch_fct.call_count, 1)
def test_file_settings(self): with patch.object(PluginController, '_Settings') as patch_fct: controller = PluginController() controller._main_window.actionSettings.trigger() self.assertEqual(patch_fct.call_count, 1)
def test_file_open_button(self): with patch.object(PluginController, '_Open') as patch_fct: controller = PluginController() QTest.mouseClick(controller._main_window.pushButton_Open, Qt.LeftButton) self.assertEqual(patch_fct.call_count, 1)
def test_help_website(self): with patch('kratos_salome_plugin.gui.plugin_controller.webbrowser') as patch_fct: controller = PluginController() controller._main_window.actionWebsite.trigger() self.assertEqual(patch_fct.open.call_count, 1)
def test_help_about(self): with patch('kratos_salome_plugin.gui.plugin_controller.ShowAbout') as patch_fct: controller = PluginController() controller._main_window.actionAbout.trigger() self.assertEqual(patch_fct.call_count, 1)
def test_kratos_load_application_button(self): with patch.object(PluginController, '_LoadApplication') as patch_fct: controller = PluginController() QTest.mouseClick(controller._main_window.pushButton_Load_Application, Qt.LeftButton) self.assertEqual(patch_fct.call_count, 1)
def test_kratos_import_mdpa(self): with patch.object(PluginController, '_ImportMdpa') as patch_fct: controller = PluginController() controller._main_window.actionImport_MDPA.trigger() self.assertEqual(patch_fct.call_count, 1)
def InitializePlugin(context): """Main function for initializing / opening the plugin This is called each time the user opens the KratosMultiphysics plugin in Salome """ ### for development/debugging reinitialize_every_time = False # default value: False # CONFIG # python imports import logging logger = logging.getLogger(__name__) # plugin imports from kratos_salome_plugin.gui.plugin_controller import PluginController import kratos_salome_plugin.gui.active_window as active_window import kratos_salome_plugin.version as plugin_version from kratos_salome_plugin import salome_utilities from kratos_salome_plugin.reload_modules import ReloadModules # salome imports import qtsalome # qt imports from PyQt5.QtWidgets import QMessageBox ### initializing the plugin ### logger.info("") logger.info("Starting to initialize plugin") # logging configuration logger.info('Reinitialize Plugin every time: %s', reinitialize_every_time) if reinitialize_every_time: ReloadModules() global VERSION_CHECKS_PERFORMED if 'VERSION_CHECKS_PERFORMED' not in globals(): # doing the version check only once per session and not every time the plugin is reopened VERSION_CHECKS_PERFORMED = 1 # check version of py-qt expected_qt_version = 5 if not qtsalome.QT_SALOME_VERSION == expected_qt_version: logger.warning('The version of PyQt has changed, from %d to %d!', expected_qt_version, qtsalome.QT_SALOME_VERSION) # check if version of salome is among the checked versions salome_versions = salome_utilities.GetVersions() if salome_versions not in plugin_version.TESTED_SALOME_VERSIONS: msg = 'This Plugin is not tested with this version of Salome ({}.{}.{}).\n'.format( *salome_versions) msg += 'The tested versions are:' for v in plugin_version.TESTED_SALOME_VERSIONS: msg += '\n {}.{}.{}'.format(*v) QMessageBox.warning(None, 'Untested Salome Version', msg) global PLUGIN_CONTROLLER if 'PLUGIN_CONTROLLER' not in globals() or reinitialize_every_time: # initialize only once the PluginController PLUGIN_CONTROLLER = PluginController() active_window.ACTIVE_WINDOW.ShowOnTop() logger.info("Successfully initialized plugin")