def test_on_go_live_preview_controller(): """ Test that when the on_go_preview() method is called the message is sent to the preview controller and focus is set correctly. """ # GIVEN: A new SlideController instance and plugin preview then pressing go live should respond mocked_display = MagicMock() mocked_preview_controller = MagicMock() mocked_preview_widget = MagicMock() mocked_service_item = MagicMock() mocked_service_item.from_service = False mocked_preview_widget.current_slide_number.return_value = 1 mocked_preview_widget.slide_count = MagicMock(return_value=2) mocked_preview_controller.preview_widget = MagicMock() Registry.create() Registry().register('preview_controller', mocked_preview_controller) slide_controller = SlideController(None) slide_controller.service_item = mocked_service_item slide_controller.preview_widget = mocked_preview_widget slide_controller.displays = [mocked_display] # WHEN: on_go_live() is called slide_controller.on_go_preview() # THEN: the preview controller should have the service item and the focus set to live mocked_preview_controller.preview_widget.setFocus.assert_called_once_with()
def dropEvent(self, event): """ Receive drop event, check if it is a file or internal object and process it if it is. :param event: Handle of the event pint passed """ # If we are on Windows, OpenLP window will not be set on top. For example, user can drag images to Library and # the folder stays on top of the group creation box. This piece of code fixes this issue. if is_win(): self.setWindowState(self.windowState() & ~QtCore.Qt.WindowMinimized | QtCore.Qt.WindowActive) self.setWindowState(QtCore.Qt.WindowNoState) if event.mimeData().hasUrls(): event.setDropAction(QtCore.Qt.CopyAction) event.accept() file_paths = handle_mime_data_urls(event.mimeData()) Registry().execute('%s_dnd' % self.mime_data_text, { 'file_paths': file_paths, 'target': self.itemAt(event.pos()) }) elif self.allow_internal_dnd: event.setDropAction(QtCore.Qt.CopyAction) event.accept() Registry().execute('%s_dnd_internal' % self.mime_data_text, self.itemAt(event.pos())) else: event.ignore()
def setUp(self): Registry.create() self.registry = Registry() self.setup_application() # Mock cursor busy/normal methods. self.app.set_busy_cursor = MagicMock() self.app.set_normal_cursor = MagicMock() self.app.args = [] Registry().register('application', self.app) # Mock classes and methods used by mainwindow. with patch('openlp.core.ui.mainwindow.SettingsForm') as mocked_settings_form, \ patch('openlp.core.ui.mainwindow.ImageManager') as mocked_image_manager, \ patch('openlp.core.ui.mainwindow.LiveController') as mocked_live_controller, \ patch('openlp.core.ui.mainwindow.PreviewController') as mocked_preview_controller, \ patch('openlp.core.ui.mainwindow.OpenLPDockWidget') as mocked_dock_widget, \ patch('openlp.core.ui.mainwindow.QtWidgets.QToolBox') as mocked_q_tool_box_class, \ patch('openlp.core.ui.mainwindow.QtWidgets.QMainWindow.addDockWidget') as mocked_add_dock_method, \ patch('openlp.core.ui.mainwindow.ThemeManager') as mocked_theme_manager, \ patch('openlp.core.ui.mainwindow.Renderer') as mocked_renderer: self.mocked_settings_form = mocked_settings_form self.mocked_image_manager = mocked_image_manager self.mocked_live_controller = mocked_live_controller self.mocked_preview_controller = mocked_preview_controller self.mocked_dock_widget = mocked_dock_widget self.mocked_q_tool_box_class = mocked_q_tool_box_class self.mocked_add_dock_method = mocked_add_dock_method self.mocked_theme_manager = mocked_theme_manager self.mocked_renderer = mocked_renderer self.main_window = MainWindow()
def exec(self): """ Execute the dialog. This method sets everything back to its initial values. """ self.import_as_new_button.setEnabled(False) self.update_existing_button.setEnabled(False) # check our credentials and connection to the PlanningCenter server organization = self.planning_center_api.check_credentials() if len(organization) == 0: QtWidgets.QMessageBox.warning( self.parent(), "Authentication Failed", "Authentiation Failed. Check your \ credentials in OpenLP Settings", QtWidgets.QMessageBox.Ok) return # set the Service Type Dropdown Box from PCO service_types_list = self.planning_center_api.get_service_type_list() self.service_type_combo_box.clear() for service_type in service_types_list: self.service_type_combo_box.addItem( service_type['attributes']['name'], service_type['id']) self.service_type_combo_box.setCurrentIndex(0) self.on_plan_selection_combobox_changed() # Set the 2 lists of themes theme_manager = Registry().get('theme_manager') for theme in theme_manager.get_theme_names(): self.song_theme_selection_combo_box.addItem(theme) self.slide_theme_selection_combo_box.addItem(theme) return QtWidgets.QDialog.exec(self)
def __init__(self, parent): super(AlertsManager, self).__init__() self.timer_id = 0 self.alert_list = [] Registry().register_function('live_display_active', self.generate_alert) Registry().register_function('alerts_text', self.alert_text) self.alerts_text.connect(self.alert_text)
def test_resize_event_dbze(self, mocked_setup, MockResizeEvent, mocked_resizeEvent): """ Test that the resizeEvent method handles a divide by zero exception correctly """ # GIVEN: A ThemeForm instance with a number of mocked methods mocked_event = MagicMock() MockResizeEvent.return_value = mocked_event theme_form = ThemeForm(None) theme_form.size = MagicMock(return_value=1920) theme_form.preview_area_layout = MagicMock() theme_form.preview_box = MagicMock(**{'width.return_value': 300}) mocked_renderer = MagicMock(**{ 'width.return_value': 1920, 'height.return_value': 0 }) Registry().remove('renderer') Registry().register('renderer', mocked_renderer) # WHEN: resizeEvent() is called theme_form.resizeEvent() # THEN: The correct calls should have been made MockResizeEvent.assert_called_once_with(1920, 1920) mocked_resizeEvent.assert_called_once_with(theme_form, mocked_event) assert mocked_renderer.width.call_count == 2 mocked_renderer.height.assert_called_once() theme_form.preview_area_layout.set_aspect_ratio.assert_called_once_with( 1) theme_form.preview_box.set_scale.assert_called_once_with( float(300 / 1920))
def setUp(self): """ Create the UI """ Registry.create() self.registry = Registry() self.setup_application() # Mock cursor busy/normal methods. self.app.set_busy_cursor = MagicMock() self.app.set_normal_cursor = MagicMock() self.app.args = [] Registry().register('application', self.app) Registry().set_flag('no_web_server', True) # Mock classes and methods used by mainwindow. with patch('openlp.core.ui.mainwindow.SettingsForm'), \ patch('openlp.core.ui.mainwindow.ImageManager'), \ patch('openlp.core.ui.mainwindow.LiveController'), \ patch('openlp.core.ui.mainwindow.PreviewController'), \ patch('openlp.core.ui.mainwindow.OpenLPDockWidget'), \ patch('openlp.core.ui.mainwindow.QtWidgets.QToolBox'), \ patch('openlp.core.ui.mainwindow.QtWidgets.QMainWindow.addDockWidget'), \ patch('openlp.core.ui.mainwindow.ServiceManager'), \ patch('openlp.core.ui.mainwindow.ThemeManager'), \ patch('openlp.core.ui.mainwindow.ProjectorManager'), \ patch('openlp.core.ui.mainwindow.Renderer'), \ patch('openlp.core.ui.mainwindow.websockets.WebSocketServer'), \ patch('openlp.core.ui.mainwindow.server.HttpServer'): self.main_window = MainWindow()
def test_on_go_live_service_manager(self): """ Test that when the on_go_live() method is called the message is sent to the live controller and focus is set correctly. """ # GIVEN: A new SlideController instance and service manager preview then pressing go live should respond mocked_display = MagicMock() mocked_service_manager = MagicMock() mocked_live_controller = MagicMock() mocked_preview_widget = MagicMock() mocked_service_item = MagicMock() mocked_service_item.from_service = True mocked_service_item.unique_identifier = 42 mocked_preview_widget.current_slide_number.return_value = 1 mocked_preview_widget.slide_count = MagicMock(return_value=2) mocked_live_controller.preview_widget = MagicMock() Registry.create() Registry().register('live_controller', mocked_live_controller) Registry().register('service_manager', mocked_service_manager) slide_controller = SlideController(None) slide_controller.service_item = mocked_service_item slide_controller.preview_widget = mocked_preview_widget slide_controller.display = mocked_display # WHEN: on_go_live() is called slide_controller.on_go_live() # THEN: the service manager should have the service item and the focus set to live mocked_service_manager.preview_live.assert_called_once_with(42, 1) mocked_live_controller.preview_widget.setFocus.assert_called_once_with()
def test_on_slide_selected_index_service_item_command(self, mocked_execute): """ Test that when there is a command service item, the command is executed """ # GIVEN: A mocked service item and a slide controller with a service item mocked_item = MagicMock() mocked_item.is_command.return_value = True mocked_item.name = 'Mocked Item' mocked_update_preview = MagicMock() mocked_preview_widget = MagicMock() mocked_slide_selected = MagicMock() Registry.create() slide_controller = SlideController(None) slide_controller.service_item = mocked_item slide_controller.update_preview = mocked_update_preview slide_controller.preview_widget = mocked_preview_widget slide_controller.slide_selected = mocked_slide_selected slide_controller.is_live = True # WHEN: The method is called slide_controller.on_slide_selected_index([9]) # THEN: It should have sent a notification mocked_item.is_command.assert_called_once_with() mocked_execute.assert_called_once_with('mocked item_slide', [mocked_item, True, 9]) mocked_update_preview.assert_called_once_with() assert 0 == mocked_preview_widget.change_slide.call_count, 'Change slide should not have been called' assert 0 == mocked_slide_selected.call_count, 'slide_selected should not have been called'
async def handle_websocket(request, path): """ Handle web socket requests and return the poll information Check every 0.2 seconds to get the latest position and send if it changed. This only gets triggered when the first client connects. :param request: request from client :param path: determines the endpoints supported """ log.debug('WebSocket handler registered with client') previous_poll = None previous_main_poll = None poller = Registry().get('poller') if path == '/state': while True: current_poll = poller.poll() if current_poll != previous_poll: await request.send(json.dumps(current_poll).encode()) previous_poll = current_poll await asyncio.sleep(0.2) elif path == '/live_changed': while True: main_poll = poller.main_poll() if main_poll != previous_main_poll: await request.send(main_poll) previous_main_poll = main_poll await asyncio.sleep(0.2)
def setUp(self): """ Set up the patches and mocks need for all tests. """ self.setup_application() self.build_settings() self.mock_plugin = MagicMock() self.temp_folder = mkdtemp() self.mock_plugin.settings_section = self.temp_folder self.powerpoint_document_stop_presentation_patcher = patch( 'openlp.plugins.presentations.lib.powerpointcontroller.PowerpointDocument.stop_presentation' ) self.presentation_document_get_temp_folder_patcher = patch( 'openlp.plugins.presentations.lib.powerpointcontroller.PresentationDocument.get_temp_folder' ) self.presentation_document_setup_patcher = patch( 'openlp.plugins.presentations.lib.powerpointcontroller.PresentationDocument._setup' ) self.mock_powerpoint_document_stop_presentation = self.powerpoint_document_stop_presentation_patcher.start( ) self.mock_presentation_document_get_temp_folder = self.presentation_document_get_temp_folder_patcher.start( ) self.mock_presentation_document_setup = self.presentation_document_setup_patcher.start( ) self.mock_controller = MagicMock() self.mock_presentation = MagicMock() self.mock_presentation_document_get_temp_folder.return_value = 'temp folder' self.file_name = os.path.join(TEST_RESOURCES_PATH, 'presentations', 'test.pptx') self.real_controller = PowerpointController(self.mock_plugin) Settings().extend_default_settings(__default_settings__) Registry.create() Registry().register('settings', Settings())
def test_save_file_raises_permission_error(self, mocked_os, mocked_save_file_as, mocked_zipfile): """ Test that when a PermissionError is raised when trying to save a file, it is handled correctly """ # GIVEN: A service manager, a service to save mocked_main_window = MagicMock() mocked_main_window.service_manager_settings_section = 'servicemanager' Registry().register('main_window', mocked_main_window) Registry().register('application', MagicMock()) service_manager = ServiceManager(None) service_manager._service_path = MagicMock() service_manager._save_lite = False service_manager.service_items = [] service_manager.service_theme = 'Default' service_manager.service_manager_list = MagicMock() mocked_save_file_as.return_value = True mocked_zipfile.ZipFile.return_value = MagicMock() mocked_os.link.side_effect = PermissionError # WHEN: The service is saved and a PermissionError is raised result = service_manager.save_file() # THEN: The "save_as" method is called to save the service assert result is True mocked_save_file_as.assert_called_with()
def setUp(self): """ Create the registry """ self.setup_application() Registry.create() self.build_settings()
def __init__(self, manager, **kwargs): """ Initialise and create defaults for properties :param manager: An instance of a SongManager, through which all database access is performed. :param kwargs: """ self.manager = manager QtCore.QObject.__init__(self) if 'file_path' in kwargs: self.import_source = kwargs['file_path'] elif 'file_paths' in kwargs: self.import_source = kwargs['file_paths'] elif 'folder_path' in kwargs: self.import_source = kwargs['folder_path'] else: raise KeyError( 'Keyword arguments "file_path[s]" or "folder_path" not supplied.' ) log.debug(self.import_source) self.import_wizard = None self.song = None self.stop_import_flag = False self.set_defaults() Registry().register_function('openlp_stop_wizard', self.stop_import) self.settings = Registry().get('settings')
def setUp(self): """ Set up the environment for testing bible queries with 1 Timothy 3 """ self.setup_application() self.build_settings() Registry.create() Registry().register('service_list', MagicMock()) Registry().register('application', MagicMock()) bible_settings = { 'bibles/proxy name': '', 'bibles/db type': 'sqlite', 'bibles/book name language': LanguageSelection.Bible, 'bibles/verse separator': '', 'bibles/range separator': '', 'bibles/list separator': '', 'bibles/end separator': '', } Settings().extend_default_settings(bible_settings) with patch('openlp.core.common.applocation.Settings') as mocked_class, \ patch('openlp.core.common.applocation.AppLocation.get_section_data_path') as mocked_get_data_path, \ patch('openlp.core.common.applocation.AppLocation.get_files') as mocked_get_files: # GIVEN: A mocked out Settings class and a mocked out AppLocation.get_files() mocked_settings = mocked_class.return_value mocked_settings.contains.return_value = False mocked_get_files.return_value = ["tests.sqlite"] mocked_get_data_path.return_value = TEST_RESOURCES_PATH + "/bibles" self.manager = BibleManager(MagicMock())
def setUp(self): """ Set up the components need for all tests. """ Registry.create() Registry().register('service_list', MagicMock()) Registry().register('main_window', MagicMock()) self.mocked_plugin = MagicMock() with patch('openlp.core.lib.mediamanageritem.MediaManagerItem._setup'), \ patch('openlp.plugins.songs.forms.editsongform.EditSongForm.__init__'): self.media_item = SongMediaItem(None, self.mocked_plugin) self.media_item.save_auto_select_id = MagicMock() self.media_item.list_view = MagicMock() self.media_item.list_view.save_auto_select_id = MagicMock() self.media_item.list_view.clear = MagicMock() self.media_item.list_view.addItem = MagicMock() self.media_item.list_view.setCurrentItem = MagicMock() self.media_item.auto_select_id = -1 self.media_item.display_songbook = False self.media_item.display_copyright_symbol = False self.setup_application() self.build_settings() Settings().extend_default_settings(__default_settings__) self.settings = self.setting Registry().register('settings', self.settings) QtCore.QLocale.setDefault(QtCore.QLocale('en_GB'))
def deregister_display(self): """ De-register this displays callbacks in the registry to be able to remove it """ if self.is_display: Registry().remove_function('live_display_hide', self.hide_display) Registry().remove_function('live_display_show', self.show_display)
def run_thread(worker, thread_name, can_start=True): """ Create a thread and assign a worker to it. This removes a lot of boilerplate code from the codebase. :param QObject worker: A QObject-based worker object which does the actual work. :param str thread_name: The name of the thread, used to keep track of the thread. :param bool can_start: Start the thread. Defaults to True. """ if not thread_name: raise ValueError('A thread_name is required when calling the "run_thread" function') application = Registry().get('application') if thread_name in application.worker_threads: raise KeyError('A thread with the name "{}" has already been created, please use another'.format(thread_name)) # Create the thread and add the thread and the worker to the parent thread = QtCore.QThread() application.worker_threads[thread_name] = { 'thread': thread, 'worker': worker } # Move the worker into the thread's context worker.moveToThread(thread) # Connect slots and signals thread.started.connect(worker.start) worker.quit.connect(thread.quit) worker.quit.connect(worker.deleteLater) thread.finished.connect(thread.deleteLater) thread.finished.connect(make_remove_thread(thread_name)) if can_start: thread.start()
def get_service_items(): """ Read the service item in use and return the data as a json object """ live_controller = Registry().get('live_controller') service_items = [] if live_controller.service_item: current_unique_identifier = live_controller.service_item.unique_identifier else: current_unique_identifier = None for item in Registry().get('service_manager').service_items: service_item = item['service_item'] service_items.append({ 'id': str(service_item.unique_identifier), 'title': str(service_item.get_display_title()), 'plugin': str(service_item.name), 'notes': str(service_item.notes), 'selected': (service_item.unique_identifier == current_unique_identifier) }) return service_items
def test_on_slide_selected_index_service_item_not_command(self, mocked_execute): """ Test that when there is a service item but it's not a command, the preview widget is updated """ # GIVEN: A mocked service item and a slide controller with a service item mocked_item = MagicMock() mocked_item.is_command.return_value = False mocked_item.name = 'Mocked Item' mocked_update_preview = MagicMock() mocked_preview_widget = MagicMock() mocked_slide_selected = MagicMock() Registry.create() slide_controller = SlideController(None) slide_controller.service_item = mocked_item slide_controller.update_preview = mocked_update_preview slide_controller.preview_widget = mocked_preview_widget slide_controller.slide_selected = mocked_slide_selected # WHEN: The method is called slide_controller.on_slide_selected_index([7]) # THEN: It should have sent a notification mocked_item.is_command.assert_called_once_with() assert 0 == mocked_execute.call_count, 'Execute should not have been called' assert 0 == mocked_update_preview.call_count, 'Update preview should not have been called' mocked_preview_widget.change_slide.assert_called_once_with(7) mocked_slide_selected.assert_called_once_with()
def test_check_media(self, mocked_is_thread_finished, mocked_run_thread, MockCheckMediaWorker): """ Test the check_media() method of the SystemPlayer """ # GIVEN: A SystemPlayer instance and a mocked thread valid_file = '/path/to/video.ogv' mocked_application = MagicMock() Registry().create() Registry().register('application', mocked_application) player = SystemPlayer(self) mocked_is_thread_finished.side_effect = [False, True] mocked_check_media_worker = MagicMock() mocked_check_media_worker.result = True MockCheckMediaWorker.return_value = mocked_check_media_worker # WHEN: check_media() is called with a valid media file result = player.check_media(valid_file) # THEN: It should return True MockCheckMediaWorker.assert_called_once_with(valid_file) mocked_check_media_worker.setVolume.assert_called_once_with(0) mocked_run_thread.assert_called_once_with(mocked_check_media_worker, 'check_media') mocked_is_thread_finished.assert_called_with('check_media') assert mocked_is_thread_finished.call_count == 2, 'is_thread_finished() should have been called twice' mocked_application.processEvents.assert_called_once_with() assert result is True
def add_handler(self, controller, file, hide_mode, slide_no): """ Add a handler, which is an instance of a presentation and slidecontroller combination. If the slidecontroller has a display then load the presentation. """ log.debug('Live = {live}, add_handler {handler}'.format( live=self.is_live, handler=file)) self.controller = controller if self.doc is not None: self.shutdown() self.doc = self.controller.add_document(file) if not self.doc.load_presentation(): # Display error message to user # Inform slidecontroller that the action failed? self.doc.slidenumber = 0 return self.doc.slidenumber = slide_no self.hide_mode = hide_mode log.debug( 'add_handler, slide_number: {slide:d}'.format(slide=slide_no)) if self.is_live: if hide_mode == HideMode.Screen: Registry().execute('live_display_hide', HideMode.Screen) self.stop() elif hide_mode == HideMode.Theme: self.blank(hide_mode) elif hide_mode == HideMode.Blank: self.blank(hide_mode) else: self.doc.start_presentation() Registry().execute('live_display_hide', HideMode.Screen) self.doc.slidenumber = 1 if slide_no > 1: self.slide(slide_no)
def on_edit_auth_button_clicked(self): """ Open the edit auth screen """ self.done(QtWidgets.QDialog.Accepted) settings_form = Registry().get('settings_form') settings_form.exec(translate('PlanningCenterPlugin', 'PlanningCenter'))
def setUp(self, mocked_init_url): """ Set up anything necessary for all tests """ self.tmp_folder = mkdtemp(prefix='openlp_') # Create a test app to keep from segfaulting Registry.create() self.registry = Registry() self.setup_application() # Mock cursor busy/normal methods. self.app.set_busy_cursor = MagicMock() self.app.set_normal_cursor = MagicMock() self.app.args = [] Registry().register('application', self.app) Registry().set_flag('no_web_server', True) # Mock classes and methods used by mainwindow. with patch('openlp.core.ui.mainwindow.SettingsForm'), \ patch('openlp.core.ui.mainwindow.OpenLPDockWidget'), \ patch('openlp.core.ui.mainwindow.QtWidgets.QToolBox'), \ patch('openlp.core.ui.mainwindow.QtWidgets.QMainWindow.addDockWidget'), \ patch('openlp.core.ui.mainwindow.ServiceManager'), \ patch('openlp.core.ui.mainwindow.ThemeManager'), \ patch('openlp.core.ui.mainwindow.ProjectorManager'), \ patch('openlp.core.ui.mainwindow.WebSocketServer'), \ patch('openlp.core.ui.mainwindow.HttpServer'), \ patch('openlp.core.ui.mainwindow.start_zeroconf'), \ patch('openlp.core.state.State.list_plugins') as mock_plugins: mock_plugins.return_value = [] self.main_window = MainWindow() tmpdb_url = 'sqlite:///{db}'.format( db=os.path.join(self.tmp_folder, TEST_DB)) mocked_init_url.return_value = tmpdb_url self.projector = ProjectorDB()
def setUp(self): """ Create the UI """ Registry.create() mocked_renderer = MagicMock() Registry().register('renderer', mocked_renderer)
def setUp(self): """ Patch and set up the mocks required. """ Registry.create() self.add_copyright_patcher = patch( 'openlp.plugins.songs.lib.importers.%s.%s.add_copyright' % (self.importer_module_name, self.importer_class_name)) self.add_verse_patcher = patch( 'openlp.plugins.songs.lib.importers.%s.%s.add_verse' % (self.importer_module_name, self.importer_class_name)) self.finish_patcher = patch( 'openlp.plugins.songs.lib.importers.%s.%s.finish' % (self.importer_module_name, self.importer_class_name)) self.add_author_patcher = patch( 'openlp.plugins.songs.lib.importers.%s.%s.add_author' % (self.importer_module_name, self.importer_class_name)) self.song_import_patcher = patch( 'openlp.plugins.songs.lib.importers.%s.SongImport' % self.importer_module_name) self.mocked_add_copyright = self.add_copyright_patcher.start() self.mocked_add_verse = self.add_verse_patcher.start() self.mocked_finish = self.finish_patcher.start() self.mocked_add_author = self.add_author_patcher.start() self.mocked_song_importer = self.song_import_patcher.start() self.mocked_manager = MagicMock() self.mocked_import_wizard = MagicMock() self.mocked_finish.return_value = True
def get_theme_data(self, theme_level=None): """ Get the theme appropriate for this item :param theme_level: The theme_level to use, the value in Settings is used when this value is missinig """ if theme_level is None: theme_level = self.settings.value('themes/theme level') theme_manager = Registry().get('theme_manager') # Just assume we use the global theme. theme = theme_manager.global_theme if theme_level != ThemeLevel.Global: service_theme = self.settings.value('servicemanager/service theme') # Service or Song level, so assume service theme (if it exists and item in service) # but use song theme if level is song (and it exists) if service_theme and self.from_service: theme = service_theme if theme_level == ThemeLevel.Song and self.theme: theme = self.theme theme = theme_manager.get_theme_data(theme) # Clean up capabilities and reload from the theme. if self.is_text(): if self.is_capable(ItemCapabilities.CanStream): self.remove_capability(ItemCapabilities.CanStream) if self.is_capable(ItemCapabilities.HasBackgroundVideo): self.remove_capability(ItemCapabilities.HasBackgroundVideo) if theme.background_type == BackgroundType.to_string(BackgroundType.Stream): self.add_capability(ItemCapabilities.CanStream) if theme.background_type == BackgroundType.to_string(BackgroundType.Video): self.video_file_name = theme.background_filename self.add_capability(ItemCapabilities.HasBackgroundVideo) return theme
def setUp(self): """ Set up the objects we need for all of the tests """ Registry.create() self.registry = Registry() self.setup_application() # Mock cursor busy/normal methods. self.app.set_busy_cursor = MagicMock() self.app.set_normal_cursor = MagicMock() self.app.process_events = MagicMock() self.app.args = [] Registry().register('application', self.app) Registry().set_flag('no_web_server', True) self.add_toolbar_action_patcher = patch( 'openlp.core.ui.mainwindow.create_action') self.mocked_add_toolbar_action = self.add_toolbar_action_patcher.start( ) self.mocked_add_toolbar_action.side_effect = self._create_mock_action with patch('openlp.core.display.screens.ScreenList.__instance__', spec=ScreenList) as mocked_screen_list: mocked_screen_list.current = { 'number': 0, 'size': QtCore.QSize(600, 800), 'primary': True } self.main_window = MainWindow()
def setUp(self): """ Create the UI """ self.registry = Registry() Registry.create() self.setup_application() self.build_settings() State().load_settings() Registry().register('settings', Settings()) Registry().register( 'main_window', MagicMock(service_manager_settings_section='servicemanager')) self.application_id = 'abc' self.secret = '123' Settings().setValue('planningcenter/application_id', self.application_id) Settings().setValue('planningcenter/secret', self.secret) # init the planning center plugin so we have default values defined for Settings() self.planning_center_plugin = PlanningCenterPlugin() # setup our form self.form = SelectPlanForm() self.form.planning_center_api.airplane_mode = True self.form.planning_center_api.airplane_mode_directory = TEST_PATH self.theme_manager = ThemeManager(None) self.theme_manager.get_theme_names = MagicMock() self.theme_manager.get_theme_names.return_value = ['themeA', 'themeB']
def setUp(self): self.sample_theme_data = { 'file_name': 'BlueBurst.otz', 'sha256': 'sha_256_hash', 'thumbnail': 'BlueBurst.png', 'title': 'Blue Burst' } Registry.create() self.registry = Registry() mocked_app = MagicMock() mocked_app.worker_threads = {} Registry().register('application', mocked_app) self.setup_application() move_to_thread_patcher = patch( 'openlp.core.ui.firsttimeform.DownloadWorker.moveToThread') self.addCleanup(move_to_thread_patcher.stop) move_to_thread_patcher.start() set_icon_patcher = patch( 'openlp.core.ui.firsttimeform.ThemeListWidgetItem.setIcon') self.addCleanup(set_icon_patcher.stop) self.mocked_set_icon = set_icon_patcher.start() q_thread_patcher = patch('openlp.core.ui.firsttimeform.QtCore.QThread') self.addCleanup(q_thread_patcher.stop) q_thread_patcher.start()
def setUp(self): """ Create the UI """ Registry.create()