def test_write_theme_same_image(self): """ Test that we don't try to overwrite a theme background image with itself """ # GIVEN: A new theme manager instance, with mocked builtins.open, shutil.copyfile, # theme, check_directory_exists and thememanager-attributes. with patch('builtins.open') as mocked_open, \ patch('openlp.core.ui.thememanager.shutil.copyfile') as mocked_copyfile, \ patch('openlp.core.ui.thememanager.check_directory_exists') as mocked_check_directory_exists: mocked_open.return_value = MagicMock() theme_manager = ThemeManager(None) theme_manager.old_background_image = None theme_manager.generate_and_save_image = MagicMock() theme_manager.path = '' mocked_theme = MagicMock() mocked_theme.theme_name = 'themename' mocked_theme.extract_formatted_xml = MagicMock() mocked_theme.extract_formatted_xml.return_value = 'fake_theme_xml'.encode() # WHEN: Calling _write_theme with path to the same image, but the path written slightly different file_name1 = os.path.join(TEST_RESOURCES_PATH, 'church.jpg') # Do replacement from end of string to avoid problems with path start file_name2 = file_name1[::-1].replace(os.sep, os.sep + os.sep, 2)[::-1] theme_manager._write_theme(mocked_theme, file_name1, file_name2) # THEN: The mocked_copyfile should not have been called self.assertFalse(mocked_copyfile.called, 'shutil.copyfile should not be called')
def test_start_presentation(self, media_mock): """ Find and chose a controller to play a presentations. """ # GIVEN: A single controller and service item wanting to use the controller mock_item = MagicMock() mock_item.processor = 'Powerpoint' mock_item.get_frame_path.return_value = "test.ppt" self.media_item.automatic = False mocked_controller = MagicMock() mocked_controller.available = True mocked_controller.supports = ['ppt'] controllers = { 'Powerpoint': mocked_controller } ml = MessageListener(self.media_item) ml.media_item = self.media_item ml.controllers = controllers ml.preview_handler = MagicMock() ml.timer = MagicMock() # WHEN: request the presentation to start ml.startup([mock_item, False, False, False]) # THEN: The controllers will be setup. self.assertTrue(len(controllers), 'We have loaded a controller')
def paint_event_text_fits_test(self): """ Test the paintEvent method when text fits the label """ font = QtGui.QFont() metrics = QtGui.QFontMetrics(font) with patch('openlp.core.ui.slidecontroller.QtGui.QLabel'), \ patch('openlp.core.ui.slidecontroller.QtGui.QPainter') as mocked_qpainter: # GIVEN: An instance of InfoLabel, with mocked text return, width and rect methods info_label = InfoLabel() test_string = 'Label Text' mocked_rect = MagicMock() mocked_text = MagicMock() mocked_width = MagicMock() mocked_text.return_value = test_string info_label.rect = mocked_rect info_label.text = mocked_text info_label.width = mocked_width # WHEN: The instance is wider than its text, and the paintEvent method is called info_label.width.return_value = metrics.boundingRect(test_string).width() + 10 info_label.paintEvent(MagicMock()) # THEN: The text should be drawn centered with the complete test_string mocked_qpainter().drawText.assert_called_once_with(mocked_rect(), QtCore.Qt.AlignCenter, test_string)
def pyodbc_exception_test(self): """ Test that exceptions raised by pyodbc are handled """ # GIVEN: A mocked out SongImport class, a mocked out pyodbc module, a mocked out translate method, # a mocked "manager" and a mocked out log_error method. with patch('openlp.plugins.songs.lib.importers.worshipcenterpro.SongImport'), \ patch('openlp.plugins.songs.lib.importers.worshipcenterpro.pyodbc.connect') as mocked_pyodbc_connect, \ patch('openlp.plugins.songs.lib.importers.worshipcenterpro.translate') as mocked_translate: mocked_manager = MagicMock() mocked_log_error = MagicMock() mocked_translate.return_value = 'Translated Text' importer = WorshipCenterProImport(mocked_manager, filenames=[]) importer.log_error = mocked_log_error importer.import_source = 'import_source' pyodbc_errors = [pyodbc.DatabaseError, pyodbc.IntegrityError, pyodbc.InternalError, pyodbc.OperationalError] mocked_pyodbc_connect.side_effect = pyodbc_errors # WHEN: Calling the do_import method for effect in pyodbc_errors: return_value = importer.do_import() # THEN: do_import should return None, and pyodbc, translate & log_error are called with known calls self.assertIsNone(return_value, 'do_import should return None when pyodbc raises an exception.') mocked_pyodbc_connect.assert_called_with('DRIVER={Microsoft Access Driver (*.mdb)};DBQ=import_source') mocked_translate.assert_called_with('SongsPlugin.WorshipCenterProImport', 'Unable to connect the WorshipCenter Pro database.') mocked_log_error.assert_called_with('import_source', 'Translated Text')
def on_slide_selected_index_service_item_not_command_test(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() self.assertEqual(0, mocked_execute.call_count, 'Execute should not have been called') self.assertEqual(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_reject_with_inactive_items(self): """ Test that the reject() method works correctly when some of the plugins are inactive """ # GIVEN: A visible general tab and an invisible theme tab in a Settings Form settings_form = SettingsForm(None) general_tab = QtWidgets.QWidget(None) general_tab.tab_title = 'mock-general' general_tab.tab_title_visible = 'Mock General' general_tab.icon_path = ':/icon/openlp-logo.svg' mocked_general_cancel = MagicMock() general_tab.cancel = mocked_general_cancel settings_form.insert_tab(general_tab, is_visible=True) themes_tab = QtWidgets.QWidget(None) themes_tab.tab_title = 'mock-themes' themes_tab.tab_title_visible = 'Mock Themes' themes_tab.icon_path = ':/icon/openlp-logo.svg' mocked_theme_cancel = MagicMock() themes_tab.cancel = mocked_theme_cancel settings_form.insert_tab(themes_tab, is_visible=False) # WHEN: The reject() method is called settings_form.reject() # THEN: The general tab's cancel() method should have been called, but not the themes tab mocked_general_cancel.assert_called_with() self.assertEqual(0, mocked_theme_cancel.call_count, 'The Themes tab\'s cancel() should not have been called')
def test_process_chapters(self, mocked_open, mocked_os): """ Test the process_chapters() method """ # GIVEN: A WordProject importer and a bunch of mocked things importer = WordProjectBible(MagicMock(), path='.', name='.', filename='kj.zip') importer.base_dir = '' importer.stop_import_flag = False importer.language_id = 'en' mocked_open.return_value.__enter__.return_value.read.return_value = CHAPTER_PAGE mocked_os.path.join.side_effect = lambda *x: ''.join(x) mocked_os.path.normpath.side_effect = lambda x: x mocked_db_book = MagicMock() mocked_db_book.name = 'Genesis' book_id = 1 book_link = '01/1.htm' # WHEN: process_chapters() is called with patch.object(importer, 'set_current_chapter') as mocked_set_current_chapter, \ patch.object(importer, 'process_verses') as mocked_process_verses: importer.process_chapters(mocked_db_book, book_id, book_link) # THEN: The right methods should have been called expected_set_current_chapter_calls = [call('Genesis', ch) for ch in range(1, 51)] expected_process_verses_calls = [call(mocked_db_book, 1, ch) for ch in range(1, 51)] mocked_os.path.join.assert_called_once_with('', '01/1.htm') mocked_open.assert_called_once_with('01/1.htm', encoding='utf-8', errors='ignore') assert mocked_set_current_chapter.call_args_list == expected_set_current_chapter_calls assert mocked_process_verses.call_args_list == expected_process_verses_calls
def test_write_theme_diff_images(self): """ Test that we do overwrite a theme background image when a new is submitted """ # GIVEN: A new theme manager instance, with mocked builtins.open, shutil.copyfile, # theme, check_directory_exists and thememanager-attributes. with patch('builtins.open') as mocked_open, \ patch('openlp.core.ui.thememanager.shutil.copyfile') as mocked_copyfile, \ patch('openlp.core.ui.thememanager.check_directory_exists') as mocked_check_directory_exists: mocked_open.return_value = MagicMock() theme_manager = ThemeManager(None) theme_manager.old_background_image = None theme_manager.generate_and_save_image = MagicMock() theme_manager.path = '' mocked_theme = MagicMock() mocked_theme.theme_name = 'themename' mocked_theme.extract_formatted_xml = MagicMock() mocked_theme.extract_formatted_xml.return_value = 'fake_theme_xml'.encode() # WHEN: Calling _write_theme with path to different images file_name1 = os.path.join(TEST_RESOURCES_PATH, 'church.jpg') file_name2 = os.path.join(TEST_RESOURCES_PATH, 'church2.jpg') theme_manager._write_theme(mocked_theme, file_name1, file_name2) # THEN: The mocked_copyfile should not have been called self.assertTrue(mocked_copyfile.called, 'shutil.copyfile should be called')
def play_test(self, mocked_get_vlc, mocked_threading): """ Test the play() method """ # GIVEN: A bunch of mocked out things mocked_thread = MagicMock() mocked_threading.Thread.return_value = mocked_thread mocked_vlc = MagicMock() mocked_get_vlc.return_value = mocked_vlc mocked_controller = MagicMock() mocked_controller.media_info.start_time = 0 mocked_controller.media_info.media_type = MediaType.Video mocked_controller.media_info.volume = 100 mocked_media = MagicMock() mocked_media.get_duration.return_value = 50000 mocked_display = MagicMock() mocked_display.controller = mocked_controller mocked_display.vlc_media_player.get_media.return_value = mocked_media vlc_player = VlcPlayer(None) vlc_player.state = MediaState.Paused # WHEN: play() is called with patch.object(vlc_player, 'media_state_wait') as mocked_media_state_wait, \ patch.object(vlc_player, 'volume') as mocked_volume: mocked_media_state_wait.return_value = True result = vlc_player.play(mocked_display) # THEN: A bunch of things should happen to play the media mocked_thread.start.assert_called_with() self.assertEqual(50, mocked_controller.media_info.length) mocked_volume.assert_called_with(mocked_display, 100) mocked_controller.seek_slider.setMaximum.assert_called_with(50000) self.assertEqual(MediaState.Playing, vlc_player.state) mocked_display.vlc_widget.raise_.assert_called_with() self.assertTrue(result, 'The value returned from play() should be True')
def test_build_song_footer_base_ccli(self): """ Test build songs footer with basic song and a CCLI number """ # GIVEN: A Song and a Service Item and a configured CCLI license mock_song = MagicMock() mock_song.title = 'My Song' mock_song.copyright = 'My copyright' service_item = ServiceItem(None) Settings().setValue('core/ccli number', '1234') # WHEN: I generate the Footer with default settings self.media_item.generate_footer(service_item, mock_song) # THEN: I get the following Array returned self.assertEqual(service_item.raw_footer, ['My Song', 'My copyright', 'CCLI License: 1234'], 'The array should be returned correctly with a song, an author, copyright and ccli') # WHEN: I amend the CCLI value Settings().setValue('core/ccli number', '4321') self.media_item.generate_footer(service_item, mock_song) # THEN: I would get an amended footer string self.assertEqual(service_item.raw_footer, ['My Song', 'My copyright', 'CCLI License: 4321'], 'The array should be returned correctly with a song, an author, copyright and amended ccli')
def test_build_song_footer_base_songbook(self): """ Test build songs footer with basic song and multiple songbooks """ # GIVEN: A Song and a Service Item song = Song() song.title = 'My Song' song.copyright = 'My copyright' song.authors_songs = [] song.songbook_entries = [] song.ccli_number = '' book1 = MagicMock() book1.name = "My songbook" book2 = MagicMock() book2.name = "Thy songbook" song.songbookentries = [] song.add_songbook_entry(book1, '12') song.add_songbook_entry(book2, '502A') service_item = ServiceItem(None) # WHEN: I generate the Footer with default settings self.media_item.generate_footer(service_item, song) # THEN: The songbook should not be in the footer self.assertEqual(service_item.raw_footer, ['My Song', 'My copyright']) # WHEN: I activate the "display songbook" option self.media_item.display_songbook = True self.media_item.generate_footer(service_item, song) # THEN: The songbook should be in the footer self.assertEqual(service_item.raw_footer, ['My Song', 'My copyright', 'My songbook #12, Thy songbook #502A'])
def test_check_media(self, MockQThread, 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_thread = MagicMock() mocked_thread.isRunning.side_effect = [True, False] mocked_thread.quit = 'quit' # actually supposed to be a slot, but it's all mocked out anyway MockQThread.return_value = mocked_thread mocked_check_media_worker = MagicMock() mocked_check_media_worker.play = 'play' 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 MockQThread.assert_called_once_with() MockCheckMediaWorker.assert_called_once_with(valid_file) mocked_check_media_worker.setVolume.assert_called_once_with(0) mocked_check_media_worker.moveToThread.assert_called_once_with(mocked_thread) mocked_check_media_worker.finished.connect.assert_called_once_with('quit') mocked_thread.started.connect.assert_called_once_with('play') mocked_thread.start.assert_called_once_with() self.assertEqual(2, mocked_thread.isRunning.call_count) mocked_application.processEvents.assert_called_once_with() self.assertTrue(result)
def test_save_file_raises_permission_error(self, mocked_save_file_as, mocked_zipfile, mocked_shutil_copy): """ 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._file_name = os.path.join('temp', 'filename.osz') 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_shutil_copy.side_effect = PermissionError # WHEN: The service is saved and a PermissionError is thrown result = service_manager.save_file() # THEN: The "save_as" method is called to save the service self.assertTrue(result) mocked_save_file_as.assert_called_with()
def setup_osx_test(self, MockedSettings, MockedQtGui, mocked_get_vlc, mocked_is_macosx, mocked_is_win): """ Test the setup method when running on OS X """ # GIVEN: A bunch of mocked out stuff and a VlcPlayer object mocked_is_macosx.return_value = True mocked_is_win.return_value = False mocked_settings = MagicMock() mocked_settings.value.return_value = False MockedSettings.return_value = mocked_settings mocked_qframe = MagicMock() mocked_qframe.winId.return_value = 2 MockedQtGui.QFrame.NoFrame = 1 MockedQtGui.QFrame.return_value = mocked_qframe mocked_media_player_new = MagicMock() mocked_instance = MagicMock() mocked_instance.media_player_new.return_value = mocked_media_player_new mocked_vlc = MagicMock() mocked_vlc.Instance.return_value = mocked_instance mocked_get_vlc.return_value = mocked_vlc mocked_display = MagicMock() mocked_display.has_audio = False mocked_display.controller.is_live = True mocked_display.size.return_value = (10, 10) vlc_player = VlcPlayer(None) # WHEN: setup() is run vlc_player.setup(mocked_display) # THEN: set_nsobject should be called mocked_media_player_new.set_nsobject.assert_called_with(2)
def build_song_footer_base_songbook_test(self): """ Test build songs footer with basic song and a songbook """ # GIVEN: A Song and a Service Item mock_song = MagicMock() mock_song.title = 'My Song' mock_song.copyright = 'My copyright' mock_song.book = MagicMock() mock_song.book.name = "My songbook" mock_song.song_number = 12 service_item = ServiceItem(None) # WHEN: I generate the Footer with default settings self.media_item.generate_footer(service_item, mock_song) # THEN: The songbook should not be in the footer self.assertEqual(service_item.raw_footer, ['My Song', 'My copyright']) # WHEN: I activate the "display songbook" option self.media_item.display_songbook = True self.media_item.generate_footer(service_item, mock_song) # THEN: The songbook should be in the footer self.assertEqual(service_item.raw_footer, ['My Song', 'My copyright', 'My songbook #12'])
def test_build_html_video(self, MockedSettings, Mocked_build_html): # GIVEN: Mocked display display = MagicMock() mocked_media_controller = MagicMock() Registry.create() Registry().register('media_controller', mocked_media_controller) main_display = MainDisplay(display) main_display.frame = MagicMock() mocked_settings = MagicMock() mocked_settings.value.return_value = False MockedSettings.return_value = mocked_settings main_display.shake_web_view = MagicMock() service_item = MagicMock() service_item.theme_data = MagicMock() service_item.theme_data.background_type = 'video' service_item.theme_data.theme_name = 'name' service_item.theme_data.background_filename = 'background_filename' mocked_plugin = MagicMock() display.plugin_manager = PluginManager() display.plugin_manager.plugins = [mocked_plugin] main_display.web_view = MagicMock() # WHEN: build_html is called with a normal service item and a video theme. main_display.build_html(service_item) # THEN: the following should had not been called self.assertEquals(main_display.web_view.setHtml.call_count, 1, 'setHTML should be called once') self.assertEquals(main_display.media_controller.video.call_count, 1, 'Media Controller video should have been called once')
def paint_event_text_doesnt_fit_test(self): """ Test the paintEvent method when text fits the label """ font = QtGui.QFont() metrics = QtGui.QFontMetrics(font) with patch('openlp.core.ui.slidecontroller.QtGui.QLabel'), \ patch('openlp.core.ui.slidecontroller.QtGui.QPainter') as mocked_qpainter: # GIVEN: An instance of InfoLabel, with mocked text return, width and rect methods info_label = InfoLabel() test_string = 'Label Text' mocked_rect = MagicMock() mocked_text = MagicMock() mocked_width = MagicMock() mocked_text.return_value = test_string info_label.rect = mocked_rect info_label.text = mocked_text info_label.width = mocked_width # WHEN: The instance is narrower than its text, and the paintEvent method is called label_width = metrics.boundingRect(test_string).width() - 10 info_label.width.return_value = label_width info_label.paintEvent(MagicMock()) # THEN: The text should be drawn aligned left with an elided test_string elided_test_string = metrics.elidedText(test_string, QtCore.Qt.ElideRight, label_width) mocked_qpainter().drawText.assert_called_once_with(mocked_rect(), QtCore.Qt.AlignLeft, elided_test_string)
def setup_visible_mouse_test(self, MockedSettings, MockedQtGui, mocked_get_vlc, mocked_is_macosx, mocked_is_win): """ Test the setup method when Settings().value("hide mouse") is False """ # GIVEN: A bunch of mocked out stuff and a VlcPlayer object mocked_is_macosx.return_value = False mocked_is_win.return_value = False mocked_settings = MagicMock() mocked_settings.value.return_value = False MockedSettings.return_value = mocked_settings mocked_qframe = MagicMock() mocked_qframe.winId.return_value = 2 MockedQtGui.QFrame.NoFrame = 1 MockedQtGui.QFrame.return_value = mocked_qframe mocked_media_player_new = MagicMock() mocked_instance = MagicMock() mocked_instance.media_player_new.return_value = mocked_media_player_new mocked_vlc = MagicMock() mocked_vlc.Instance.return_value = mocked_instance mocked_get_vlc.return_value = mocked_vlc mocked_display = MagicMock() mocked_display.has_audio = False mocked_display.controller.is_live = True mocked_display.size.return_value = (10, 10) vlc_player = VlcPlayer(None) # WHEN: setup() is run vlc_player.setup(mocked_display) # THEN: The VLC instance should be created with the correct options mocked_vlc.Instance.assert_called_with('--no-video-title-show --no-audio --no-video-title-show')
def build_html_test(self): """ Test the build_html() function """ # GIVEN: Mocked arguments and function. with patch('openlp.core.lib.htmlbuilder.build_background_css') as mocked_build_background_css, \ patch('openlp.core.lib.htmlbuilder.build_footer_css') as mocked_build_footer_css, \ patch('openlp.core.lib.htmlbuilder.build_lyrics_css') as mocked_build_lyrics_css: # Mocked function. mocked_build_background_css.return_value = '' mocked_build_footer_css.return_value = 'dummy: dummy;' mocked_build_lyrics_css.return_value = '' # Mocked arguments. item = MagicMock() item.bg_image_bytes = None screen = MagicMock() is_live = False background = None plugin = MagicMock() plugin.get_display_css.return_value = 'plugin CSS' plugin.get_display_javascript.return_value = 'plugin JS' plugin.get_display_html.return_value = 'plugin HTML' plugins = [plugin] # WHEN: Create the html. html = build_html(item, screen, is_live, background, plugins=plugins) # THEN: The returned html should match. self.assertEqual(html, HTML, 'The returned html should match')
def test_load_objects(self, mocked_set_case_insensitive_completer): """ Test the _load_objects() method """ # GIVEN: A song edit form and some mocked stuff mocked_class = MagicMock() mocked_class.name = 'Author' mocked_combo = MagicMock() mocked_combo.count.return_value = 0 mocked_cache = MagicMock() mocked_object = MagicMock() mocked_object.name = 'Charles' mocked_object.id = 1 mocked_manager = MagicMock() mocked_manager.get_all_objects.return_value = [mocked_object] self.edit_song_form.manager = mocked_manager # WHEN: _load_objects() is called self.edit_song_form._load_objects(mocked_class, mocked_combo, mocked_cache) # THEN: All the correct methods should have been called self.edit_song_form.manager.get_all_objects.assert_called_once_with(mocked_class) mocked_combo.clear.assert_called_once_with() mocked_combo.count.assert_called_once_with() mocked_combo.addItem.assert_called_once_with('Charles') mocked_cache.append.assert_called_once_with('Charles') mocked_combo.setItemData.assert_called_once_with(0, 1) mocked_set_case_insensitive_completer.assert_called_once_with(mocked_cache, mocked_combo) mocked_combo.setCurrentIndex.assert_called_once_with(-1) mocked_combo.setCurrentText.assert_called_once_with('')
def setUp(self): mocked_plugin = MagicMock() mocked_plugin.settings_section = 'presentations' Settings().extend_default_settings(__default_settings__) self.file_name = os.path.join(TEST_RESOURCES_PATH, 'presentations', 'test.pptx') self.ppc = ImpressController(mocked_plugin) self.doc = ImpressDocument(self.ppc, self.file_name)
def on_go_live_service_manager_test(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.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 unblank_screen_test(self): """ Test that unblank_screen works as expected """ # GIVEN: A Document with mocked controller, presentation, ScreenList, and mocked function get_slide_number with patch('openlp.plugins.presentations.lib.powerpointcontroller.ScreenList') as mocked_screen_list: mocked_screen_list_ret = MagicMock() mocked_screen_list_ret.screen_list = [1] mocked_screen_list.return_value = mocked_screen_list_ret doc = PowerpointDocument(self.mock_controller, self.mock_presentation) doc.presentation = MagicMock() doc.presentation.SlideShowWindow.View.GetClickIndex.return_value = 3 doc.presentation.Application.Version = 14.0 doc.get_slide_number = MagicMock() doc.get_slide_number.return_value = 2 doc.index_map[1] = 1 doc.blank_slide = 1 doc.blank_click = 1 # WHEN: Calling goto_slide doc.unblank_screen() # THEN: The view state have new value, and several function should have been called self.assertEquals(doc.presentation.SlideShowWindow.View.State, 1, 'The View State should be 1') self.assertEquals(doc.presentation.SlideShowWindow.Activate.called, True, 'SlideShowWindow.Activate should have been called') self.assertEquals(doc.presentation.SlideShowWindow.View.GotoSlide.called, True, 'View.GotoSlide should have been called because of the PowerPoint version') self.assertEquals(doc.presentation.SlideShowWindow.View.GotoClick.called, True, 'View.GotoClick should have been called because of the PowerPoint version')
def play_media_wait_state_not_playing_test(self, mocked_get_vlc, mocked_threading): """ Test the play() method when media_wait_state() returns False """ # GIVEN: A bunch of mocked out things mocked_thread = MagicMock() mocked_threading.Thread.return_value = mocked_thread mocked_vlc = MagicMock() mocked_get_vlc.return_value = mocked_vlc mocked_controller = MagicMock() mocked_controller.media_info.start_time = 0 mocked_display = MagicMock() mocked_display.controller = mocked_controller vlc_player = VlcPlayer(None) vlc_player.state = MediaState.Paused # WHEN: play() is called with patch.object(vlc_player, 'media_state_wait') as mocked_media_state_wait, \ patch.object(vlc_player, 'volume') as mocked_volume: mocked_media_state_wait.return_value = False result = vlc_player.play(mocked_display) # THEN: A thread should be started, but the method should return False mocked_thread.start.assert_called_with() self.assertFalse(result)
def update_ui_dvd_test(self, mocked_get_vlc): """ Test updating the UI for a CD or DVD """ # GIVEN: A whole bunch of mocks mocked_vlc = MagicMock() mocked_vlc.State.Ended = 1 mocked_get_vlc.return_value = mocked_vlc mocked_controller = MagicMock() mocked_controller.media_info.start_time = 100 mocked_controller.media_info.end_time = 300 mocked_controller.seek_slider.isSliderDown.return_value = False mocked_display = MagicMock() mocked_display.controller = mocked_controller mocked_display.vlc_media.get_state.return_value = 1 mocked_display.vlc_media_player.get_time.return_value = 400000 mocked_display.controller.media_info.media_type = MediaType.DVD vlc_player = VlcPlayer(None) # WHEN: update_ui() is called with patch.object(vlc_player, 'stop') as mocked_stop, \ patch.object(vlc_player, 'set_visible') as mocked_set_visible: vlc_player.update_ui(mocked_display) # THEN: Certain methods should be called mocked_stop.assert_called_with(mocked_display) self.assertEqual(2, mocked_stop.call_count) mocked_display.vlc_media_player.get_time.assert_called_with() mocked_set_visible.assert_called_with(mocked_display, False) mocked_controller.seek_slider.setSliderPosition.assert_called_with(300000) expected_calls = [call(True), call(False)] self.assertEqual(expected_calls, mocked_controller.seek_slider.blockSignals.call_args_list)
def on_slide_selected_index_service_item_command_test(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() self.assertEqual(0, mocked_preview_widget.change_slide.call_count, 'Change slide should not have been called') self.assertEqual(0, mocked_slide_selected.call_count, 'slide_selected should not have been called')
def accept_with_inactive_plugins_test(self): """ Test that the accept() method works correctly when some of the plugins are inactive """ # GIVEN: A visible general tab and an invisible theme tab in a Settings Form settings_form = SettingsForm(None) general_tab = QtGui.QWidget(None) general_tab.tab_title = 'mock-general' general_tab.tab_title_visible = 'Mock General' general_tab.icon_path = ':/icon/openlp-logo-16x16.png' mocked_general_save = MagicMock() general_tab.save = mocked_general_save settings_form.insert_tab(general_tab, is_visible=True) themes_tab = QtGui.QWidget(None) themes_tab.tab_title = 'mock-themes' themes_tab.tab_title_visible = 'Mock Themes' themes_tab.icon_path = ':/icon/openlp-logo-16x16.png' mocked_theme_save = MagicMock() themes_tab.save = mocked_theme_save settings_form.insert_tab(themes_tab, is_visible=False) # WHEN: The accept() method is called settings_form.accept() # THEN: The general tab's save() method should have been called, but not the themes tab mocked_general_save.assert_called_with() self.assertEqual(0, mocked_theme_save.call_count, 'The Themes tab\'s save() should not have been called')
def load_test(self, mocked_normcase, mocked_get_vlc): """ Test loading a video into VLC """ # GIVEN: A mocked out get_vlc() method media_path = '/path/to/media.mp4' mocked_normcase.side_effect = lambda x: x mocked_vlc = MagicMock() mocked_get_vlc.return_value = mocked_vlc mocked_controller = MagicMock() mocked_controller.media_info.volume = 100 mocked_controller.media_info.media_type = MediaType.Video mocked_controller.media_info.file_info.absoluteFilePath.return_value = media_path mocked_vlc_media = MagicMock() mocked_media = MagicMock() mocked_media.get_duration.return_value = 10000 mocked_display = MagicMock() mocked_display.controller = mocked_controller mocked_display.vlc_instance.media_new_path.return_value = mocked_vlc_media mocked_display.vlc_media_player.get_media.return_value = mocked_media vlc_player = VlcPlayer(None) # WHEN: A video is loaded into VLC with patch.object(vlc_player, 'volume') as mocked_volume: result = vlc_player.load(mocked_display) # THEN: The video should be loaded mocked_normcase.assert_called_with(media_path) mocked_display.vlc_instance.media_new_path.assert_called_with(media_path) self.assertEqual(mocked_vlc_media, mocked_display.vlc_media) mocked_display.vlc_media_player.set_media.assert_called_with(mocked_vlc_media) mocked_vlc_media.parse.assert_called_with() mocked_volume.assert_called_with(mocked_display, 100) self.assertEqual(10, mocked_controller.media_info.length) self.assertTrue(result)
def setUp(self): self.get_thumbnail_folder_patcher = \ patch('openlp.plugins.presentations.lib.presentationcontroller.PresentationDocument.get_thumbnail_folder') self.get_thumbnail_folder_patcher.start() mocked_plugin = MagicMock() mocked_plugin.settings_section = 'presentations' self.presentation = PresentationController(mocked_plugin) self.document = PresentationDocument(self.presentation, '')
def db_file_import_test(self): """ Test the actual import of real song database files and check that the imported data is correct. """ # GIVEN: Test files with a mocked out SongImport class, a mocked out "manager", a mocked out "import_wizard", # and mocked out "author", "add_copyright", "add_verse", "finish" methods. with patch('openlp.plugins.songs.lib.importers.easyworship.SongImport'), \ patch('openlp.plugins.songs.lib.importers.easyworship.retrieve_windows_encoding') as \ mocked_retrieve_windows_encoding: mocked_retrieve_windows_encoding.return_value = 'cp1252' mocked_manager = MagicMock() mocked_import_wizard = MagicMock() mocked_add_author = MagicMock() mocked_add_verse = MagicMock() mocked_finish = MagicMock() mocked_title = MagicMock() mocked_finish.return_value = True importer = EasyWorshipSongImportLogger(mocked_manager) importer.import_wizard = mocked_import_wizard importer.stop_import_flag = False importer.add_author = mocked_add_author importer.add_verse = mocked_add_verse importer.title = mocked_title importer.finish = mocked_finish importer.topics = [] # WHEN: Importing each file importer.import_source = os.path.join(TEST_PATH, 'Songs.DB') import_result = importer.do_import() # THEN: do_import should return none, the song data should be as expected, and finish should have been # called. self.assertIsNone(import_result, 'do_import should return None when it has completed') for song_data in SONG_TEST_DATA: title = song_data['title'] author_calls = song_data['authors'] song_copyright = song_data['copyright'] ccli_number = song_data['ccli_number'] add_verse_calls = song_data['verses'] verse_order_list = song_data['verse_order_list'] self.assertIn(title, importer._title_assignment_list, 'title for %s should be "%s"' % (title, title)) for author in author_calls: mocked_add_author.assert_any_call(author) if song_copyright: self.assertEqual(importer.copyright, song_copyright) if ccli_number: self.assertEqual(importer.ccli_number, ccli_number, 'ccli_number for %s should be %s' % (title, ccli_number)) for verse_text, verse_tag in add_verse_calls: mocked_add_verse.assert_any_call(verse_text, verse_tag) if verse_order_list: self.assertEqual(importer.verse_order_list, verse_order_list, 'verse_order_list for %s should be %s' % (title, verse_order_list)) mocked_finish.assert_called_with()
def get_song_page_raises_exception_test(self, mocked_build_opener): """ Test that when BeautifulSoup gets a bad song page the get_song() method returns None """ # GIVEN: A bunch of mocked out stuff and an importer object mocked_opener = MagicMock() mocked_build_opener.return_value = mocked_opener mocked_opener.open.read.side_effect = URLError( '[Errno -2] Name or service not known') mocked_callback = MagicMock() importer = SongSelectImport(None) # WHEN: get_song is called result = importer.get_song({'link': 'link'}, callback=mocked_callback) # THEN: The callback should have been called once and None should be returned mocked_callback.assert_called_with() self.assertIsNone(result, 'The get_song() method should have returned None')
def new_service_created_with_disabled_plugin_test(self): """ Test running the new_service_created() method with a disabled plugin """ # GIVEN: A PluginManager instance and a list with a mocked up plugin whose status is set to Disabled mocked_plugin = MagicMock() mocked_plugin.status = PluginStatus.Disabled mocked_plugin.is_active.return_value = False plugin_manager = PluginManager() plugin_manager.plugins = [mocked_plugin] # WHEN: We run finalise_plugins() plugin_manager.new_service_created() # THEN: The isActive() method should have been called, and initialise() method should NOT have been called mocked_plugin.is_active.assert_called_with() self.assertEqual( 0, mocked_plugin.new_service_created.call_count, 'The new_service_created() method should not have been called.')
def setUp(self): self.get_soup_for_bible_ref_patcher = patch( 'openlp.plugins.bibles.lib.importers.http.get_soup_for_bible_ref') self.log_patcher = patch( 'openlp.plugins.bibles.lib.importers.http.log') self.send_error_message_patcher = patch( 'openlp.plugins.bibles.lib.importers.http.send_error_message') self.socket_patcher = patch( 'openlp.plugins.bibles.lib.importers.http.socket') self.urllib_patcher = patch( 'openlp.plugins.bibles.lib.importers.http.urllib') self.mock_get_soup_for_bible_ref = self.get_soup_for_bible_ref_patcher.start( ) self.mock_log = self.log_patcher.start() self.mock_send_error_message = self.send_error_message_patcher.start() self.mock_socket = self.socket_patcher.start() self.mock_soup = MagicMock() self.mock_urllib = self.urllib_patcher.start()
def add_service_item_without_song_edit_test(self): """ Test the add_service_item() method when song_edit is False """ # GIVEN: A slide controller and a new item to add mocked_item = MagicMock() mocked_process_item = MagicMock() slide_controller = SlideController(None) slide_controller._process_item = mocked_process_item slide_controller.song_edit = False slide_controller.selected_row = 2 # WHEN: The item is added to the service slide_controller.add_service_item(mocked_item) # THEN: The item is processed, the slide number is correct, and the song is not editable (or something) mocked_item.render.assert_called_once_with() self.assertFalse(slide_controller.song_edit, 'song_edit should be False') mocked_process_item.assert_called_once_with(mocked_item, 0)
def file_import_test(self): """ Test the actual import of real song files """ # GIVEN: Test files with a mocked out "manager" and a mocked out "import_wizard" for song_file in SONG_TEST_DATA: mocked_manager = MagicMock() mocked_import_wizard = MagicMock() importer = OpenLyricsImport(mocked_manager, filenames=[]) importer.import_wizard = mocked_import_wizard importer.open_lyrics = MagicMock() importer.open_lyrics.xml_to_song = MagicMock() # WHEN: Importing each file importer.import_source = [os.path.join(TEST_PATH, song_file)] importer.do_import() # THEN: The xml_to_song() method should have been called self.assertTrue(importer.open_lyrics.xml_to_song.called)
def test_build_footer_css_wrap(self): """ Test the build_footer_css() function """ # GIVEN: Create a theme. item = MagicMock() item.footer = QtCore.QRect(10, 921, 1260, 103) item.theme_data.font_footer_name = 'Arial' item.theme_data.font_footer_size = 12 item.theme_data.font_footer_color = '#FFFFFF' height = 1024 # WHEN: Settings say that footer should wrap Settings().setValue('themes/wrap footer', True) css = build_footer_css(item, height) # THEN: Footer should wrap self.assertEqual(FOOTER_CSS_WRAP, css, 'The footer strings should be equal.')
def get_language_id_language_found_test(self): """ Test get_language_id() when called with a name found in the languages list """ # GIVEN: A mocked languages.get_language which returns language and an instance of BibleImport with patch('openlp.core.common.languages.get_language', return_value=Language(30, 'English', 'en')) \ as mocked_languages_get_language, \ patch.object(BibleImport, 'get_language') as mocked_db_get_language: instance = BibleImport(MagicMock()) instance.save_meta = MagicMock() # WHEN: Calling get_language_id() with a language name and bible name result = instance.get_language_id('English', 'KJV') # THEN: The id of the language returned from languages.get_language should be returned mocked_languages_get_language.assert_called_once_with('English') self.assertFalse(mocked_db_get_language.called) instance.save_meta.assert_called_once_with('language_id', 30) self.assertEqual(result, 30)
def test_do_import_source_invalid(self): """ Test the :mod:`do_import` module produces an error when Songs.MB not found. """ # GIVEN: A mocked out SongImport class, a mocked out "manager" with patch('openlp.plugins.songs.lib.importers.easyworship.SongImport'), \ patch('openlp.plugins.songs.lib.importers.easyworship.os.path') as mocked_os_path: mocked_manager = MagicMock() importer = EasyWorshipSongImport(mocked_manager, filenames=[]) importer.log_error = MagicMock() mocked_os_path.isfile.side_effect = [True, False] # WHEN: do_import is supplied with an import source (Songs.MB missing) importer.import_source = 'Songs.DB' importer.do_import() # THEN: do_import should have logged an error that the Songs.MB file could not be found. importer.log_error.assert_any_call(importer.import_source, 'Could not find the "Songs.MB" file. It must be ' 'in the same folder as the "Songs.DB" file.')
def test_constructor(self): """ Test the MediaShoutImport constructor """ # GIVEN: A MediaShoutImport class # WHEN: It is created importer = MediaShoutImport(MagicMock(), filename='mediashout.db') # THEN: It should not be None self.assertIsNotNone(importer)
def get_book_ref_id_by_name_book_name_form_rejected_test(self): """ Test get_book_ref_id_by_name when the user rejects the BookNameForm """ # GIVEN: An instance of BibleImport and a mocked BookNameForm which simulates a user rejecting the dialog with patch.object(BibleImport, 'log_debug'), patch.object(BibleImport, 'get_books'), \ patch('openlp.plugins.bibles.lib.bibleimport.BiblesResourcesDB', **{'get_book.return_value': None, 'get_alternative_book_name.return_value': None}), \ patch('openlp.plugins.bibles.lib.bibleimport.AlternativeBookNamesDB', **{'get_book_reference_id.return_value': None}), \ patch('openlp.plugins.bibles.forms.BookNameForm', return_value=MagicMock(**{'exec.return_value': QDialog.Rejected})): instance = BibleImport(MagicMock()) # WHEN: Calling get_book_ref_id_by_name result = instance.get_book_ref_id_by_name('Gen', 66, 4) # THEN: None should be returned self.assertIsNone(result)
def stop_test(self, mocked_threading): """ Test stopping the current item """ # GIVEN: A display object and a VlcPlayer instance and some mocked threads mocked_thread = MagicMock() mocked_threading.Thread.return_value = mocked_thread mocked_stop = MagicMock() mocked_display = MagicMock() mocked_display.vlc_media_player.stop = mocked_stop vlc_player = VlcPlayer(None) # WHEN: stop is called vlc_player.stop(mocked_display) # THEN: A thread should have been started to stop VLC mocked_threading.Thread.assert_called_with(target=mocked_stop) mocked_thread.start.assert_called_with() self.assertEqual(MediaState.Stopped, vlc_player.state)
def parse_xml_etree_use_objectify_test(self): """ Test BibleImport.parse_xml() when called with use_objectify set to True """ # GIVEN: A sample "file" to parse and an instance of BibleImport self.mocked_open.return_value = self.test_file instance = BibleImport(MagicMock()) instance.wizard = MagicMock() # WHEN: Calling parse_xml result = instance.parse_xml('file.tst', use_objectify=True) # THEN: The result returned should contain the correct data, and should be an instance of ObjectifiedElement self.assertEqual( etree.tostring(result), b'<root><data><div>Test<p>data</p><a>to</a>keep</div></data>' b'<data><unsupported>Test<x>data</x><y>to</y>discard</unsupported></data></root>' ) self.assertIsInstance(result, objectify.ObjectifiedElement)
def test_trans_off_tag(self, mocked_songimport): """ Test importing lyrics with a split and join and translations tags works in OPS Pro """ # GIVEN: A mocked out SongImport class, a mocked out "manager" and a mocked song and lyrics entry mocked_manager = MagicMock() importer = OPSProImport(mocked_manager, filenames=[]) importer.finish = MagicMock() song, lyrics = _build_data('amazing grace2.txt', True) # WHEN: An importer object is created importer.process_song(song, lyrics, []) # THEN: The imported data should look like expected result_file = open(os.path.join(TEST_PATH, 'Amazing Grace.json'), 'rb') result_data = json.loads(result_file.read().decode()) self.assertListEqual(importer.verses, _get_item(result_data, 'verses')) self.assertListEqual(importer.verse_order_list_generated, _get_item(result_data, 'verse_order_list'))
def test_replace_service_item_thumbs(self, mocked_setRowHeight, mocked_resizeRowsToContents, mocked_image_manager): """ Test that thubmails for different slides are loaded properly in replace_service_item. """ # GIVEN: A setting to adjust "Max height for non-text slides in slide controller", # different ServiceItem(s), an ImageManager, and a ListPreviewWidget. # Mock Settings().value('advanced/slide max height') self.mocked_Settings_obj.value.return_value = 0 # Mock self.viewport().width() self.mocked_viewport_obj.width.return_value = 200 # Mock Image service item mocked_img_service_item = MagicMock() mocked_img_service_item.is_text.return_value = False mocked_img_service_item.is_media.return_value = False mocked_img_service_item.is_command.return_value = False mocked_img_service_item.is_capable.return_value = False mocked_img_service_item.get_frames.return_value = [{'title': None, 'path': 'TEST1', 'image': 'FAIL'}, {'title': None, 'path': 'TEST2', 'image': 'FAIL'}] # Mock Command service item mocked_cmd_service_item = MagicMock() mocked_cmd_service_item.is_text.return_value = False mocked_cmd_service_item.is_media.return_value = False mocked_cmd_service_item.is_command.return_value = True mocked_cmd_service_item.is_capable.return_value = True mocked_cmd_service_item.get_frames.return_value = [{'title': None, 'path': 'FAIL', 'image': 'TEST3'}, {'title': None, 'path': 'FAIL', 'image': 'TEST4'}] # Mock image_manager mocked_image_manager.get_image.return_value = QtGui.QImage() # init ListPreviewWidget and load service item list_preview_widget = ListPreviewWidget(None, 1) # WHEN: replace_service_item is called list_preview_widget.replace_service_item(mocked_img_service_item, 200, 0) list_preview_widget.replace_service_item(mocked_cmd_service_item, 200, 0) # THEN: The ImageManager should be called in the appriopriate manner for each service item. self.assertEquals(mocked_image_manager.get_image.call_count, 4, 'Should be called once for each slide') calls = [call('TEST1', ImageSource.ImagePlugin), call('TEST2', ImageSource.ImagePlugin), call('TEST3', ImageSource.CommandPlugins), call('TEST4', ImageSource.CommandPlugins)] mocked_image_manager.get_image.assert_has_calls(calls)
def main_poll_test(self): """ Test the main poll logic """ # GIVEN: a defined router with two slides Registry.create() Registry().register('live_controller', MagicMock) router = HttpRouter() router.send_response = MagicMock() router.send_header = MagicMock() router.end_headers = MagicMock() router.live_controller.slide_count = 2 # WHEN: main poll called results = router.main_poll() # THEN: the correct response should be returned self.assertEqual(results.decode('utf-8'), '{"results": {"slide_count": 2}}', 'The resulting json strings should match')
def insert_tab_visible_test(self): """ Test that the insert_tab() method works correctly when a visible tab is inserted """ # GIVEN: A mocked tab and a Settings Form settings_form = SettingsForm(None) general_tab = MagicMock() general_tab.tab_title = 'mock' general_tab.tab_title_visible = 'Mock' general_tab.icon_path = ':/icon/openlp-logo-16x16.png' # WHEN: We insert the general tab with patch.object(settings_form.stacked_layout, 'addWidget') as mocked_add_widget, \ patch.object(settings_form.setting_list_widget, 'addItem') as mocked_add_item: settings_form.insert_tab(general_tab, is_visible=True) # THEN: The general tab should have been inserted into the stacked layout and an item inserted into the list mocked_add_widget.assert_called_with(general_tab) self.assertEqual(1, mocked_add_item.call_count, 'addItem should have been called')
def test_projector_reset_information(self): """ Test reset_information() resets all information and stops timers """ # GIVEN: Test object and test data pjlink = pjlink_test pjlink.power = S_ON pjlink.pjlink_name = 'OPENLPTEST' pjlink.manufacturer = 'PJLINK' pjlink.model = '1' pjlink.shutter = True pjlink.mute = True pjlink.lamp = True pjlink.fan = True pjlink.source_available = True pjlink.other_info = 'ANOTHER TEST' pjlink.send_queue = True pjlink.send_busy = True pjlink.timer = MagicMock() pjlink.socket_timer = MagicMock() # WHEN: reset_information() is called with patch.object(pjlink.timer, 'stop') as mock_timer: with patch.object(pjlink.socket_timer, 'stop') as mock_socket_timer: pjlink.reset_information() # THEN: All information should be reset and timers stopped self.assertEquals(pjlink.power, S_OFF, 'Projector power should be OFF') self.assertIsNone(pjlink.pjlink_name, 'Projector pjlink_name should be None') self.assertIsNone(pjlink.manufacturer, 'Projector manufacturer should be None') self.assertIsNone(pjlink.model, 'Projector model should be None') self.assertIsNone(pjlink.shutter, 'Projector shutter should be None') self.assertIsNone(pjlink.mute, 'Projector shuttter should be None') self.assertIsNone(pjlink.lamp, 'Projector lamp should be None') self.assertIsNone(pjlink.fan, 'Projector fan should be None') self.assertIsNone(pjlink.source_available, 'Projector source_available should be None') self.assertIsNone(pjlink.source, 'Projector source should be None') self.assertIsNone(pjlink.other_info, 'Projector other_info should be None') self.assertEquals(pjlink.send_queue, [], 'Projector send_queue should be an empty list') self.assertFalse(pjlink.send_busy, 'Projector send_busy should be False') self.assertTrue(mock_timer.called, 'Projector timer.stop() should have been called') self.assertTrue(mock_socket_timer.called, 'Projector socket_timer.stop() should have been called')
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.QtGui.QToolBox') as mocked_q_tool_box_class, \ patch('openlp.core.ui.mainwindow.QtGui.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.main_window = MainWindow()
def test_save_song_new_author(self, MockedAuthor, MockedTopic, mocked_clean_song): """ Test that saving a song with a new author performs the correct actions """ # GIVEN: A song to save, and some mocked out objects song_dict = { 'title': 'Arky Arky', 'authors': ['Public Domain'], 'verses': [{ 'label': 'Verse 1', 'lyrics': 'The Lord told Noah: there\'s gonna be a floody, floody' }, { 'label': 'Chorus 1', 'lyrics': 'So, rise and shine, and give God the glory, glory' }, { 'label': 'Verse 2', 'lyrics': 'The Lord told Noah to build him an arky, arky' }], 'copyright': 'Public Domain', 'ccli_number': '123456' } MockedAuthor.display_name.__eq__.return_value = False MockedTopic.name.__eq__.return_value = False mocked_db_manager = MagicMock() mocked_db_manager.get_object_filtered.return_value = None importer = SongSelectImport(mocked_db_manager) # WHEN: The song is saved to the database result = importer.save_song(song_dict) # THEN: The return value should be a Song class and the mocked_db_manager should have been called self.assertIsInstance(result, Song, 'The returned value should be a Song object') mocked_clean_song.assert_called_with(mocked_db_manager, result) self.assertEqual( 2, mocked_db_manager.save_object.call_count, 'The save_object() method should have been called twice') mocked_db_manager.get_object_filtered.assert_called_with( MockedAuthor, False) MockedAuthor.populate.assert_called_with(first_name='Public', last_name='Domain', display_name='Public Domain') self.assertEqual(1, len(result.authors_songs), 'There should only be one author')
def test_media_state_wait_error(self, mocked_get_vlc): """ Check that getting an error when waiting for a state change returns False """ # GIVEN: A mocked out get_vlc method mocked_vlc = MagicMock() mocked_vlc.State.Error = 1 mocked_get_vlc.return_value = mocked_vlc mocked_display = MagicMock() mocked_display.vlc_media.get_state.return_value = 1 Registry.create() mocked_application = MagicMock() Registry().register('application', mocked_application) vlc_player = VlcPlayer(None) # WHEN: media_state_wait() is called result = vlc_player.media_state_wait(mocked_display, 2) # THEN: The results should be True self.assertFalse(result)
def init_kwargs_none_test(self): """ Test the initialisation of the BibleImport Class when no key word arguments are supplied """ # GIVEN: A patched BibleDB._setup, BibleImport class and mocked parent # WHEN: Creating an instance of BibleImport with no key word arguments instance = BibleImport(MagicMock()) # THEN: The filename attribute should be None self.assertIsNone(instance.filename) self.assertIsInstance(instance, BibleDB)
def goto_slide_test(self): """ Test that goto_slide goes to next effect if the slide is already displayed """ # GIVEN: A Document with mocked controller, presentation, and mocked functions get_slide_number and next_step doc = PowerpointDocument(self.mock_controller, self.mock_presentation) doc.presentation = MagicMock() doc.presentation.SlideShowWindow.View.GetClickIndex.return_value = 1 doc.presentation.SlideShowWindow.View.GetClickCount.return_value = 2 doc.get_slide_number = MagicMock() doc.get_slide_number.return_value = 1 doc.next_step = MagicMock() doc.index_map[1] = 1 # WHEN: Calling goto_slide doc.goto_slide(1) # THEN: next_step() should be call to try to advance to the next effect. self.assertTrue(doc.next_step.called, 'next_step() should have been called!')
def do_import_invalid_language_id_test(self): """ Test do_import when the user cancels the language selection dialog box """ # GIVEN: An instance of CSVBible and a mocked get_language which simulates the user cancelling the language box mocked_manager = MagicMock() with patch('openlp.plugins.bibles.lib.db.BibleDB._setup'): importer = CSVBible(mocked_manager, path='.', name='.', booksfile='books.csv', versefile='verse.csv') importer.get_language = MagicMock(return_value=None) # WHEN: Calling do_import result = importer.do_import('Bible Name') # THEN: The False should be returned. importer.get_language.assert_called_once_with('Bible Name') self.assertFalse(result)
def test_on_web_update_button_clicked(self, mocked_bsextract, mocked_bgextract, mocked_cwextract): """ Test that on_web_update_button_clicked handles problems correctly """ # GIVEN: Some mocked GUI components and mocked bibleextractors self.form.web_source_combo_box = MagicMock() self.form.web_translation_combo_box = MagicMock() self.form.web_update_button = MagicMock() self.form.web_progress_bar = MagicMock() mocked_bsextract.return_value = None mocked_bgextract.return_value = None mocked_cwextract.return_value = None # WHEN: Running on_web_update_button_clicked self.form.on_web_update_button_clicked() # THEN: The webbible list should still be empty self.assertEqual(self.form.web_bible_list, {}, 'The webbible list should be empty')
def test_valid_import_source(self): """ Test SongShowPlusImport.do_import handles different invalid import_source values """ # GIVEN: A mocked out SongImport class, and a mocked out "manager" with patch('openlp.plugins.songs.lib.importers.songshowplus.SongImport'): mocked_manager = MagicMock() mocked_import_wizard = MagicMock() importer = SongShowPlusImport(mocked_manager, filenames=[]) importer.import_wizard = mocked_import_wizard importer.stop_import_flag = True # WHEN: Import source is a list importer.import_source = ['List', 'of', 'files'] # THEN: do_import should return none and the progress bar setMaximum should be called with the length of # import_source. self.assertIsNone(importer.do_import(), 'do_import should return None when import_source is a list ' 'and stop_import_flag is True') mocked_import_wizard.progress_bar.setMaximum.assert_called_with(len(importer.import_source))
def test_invalid_import_source(self): """ Test SongShowPlusImport.do_import handles different invalid import_source values """ # GIVEN: A mocked out SongImport class, and a mocked out "manager" with patch('openlp.plugins.songs.lib.importers.songshowplus.SongImport'): mocked_manager = MagicMock() mocked_import_wizard = MagicMock() importer = SongShowPlusImport(mocked_manager, filenames=[]) importer.import_wizard = mocked_import_wizard importer.stop_import_flag = True # WHEN: Import source is not a list for source in ['not a list', 0]: importer.import_source = source # THEN: do_import should return none and the progress bar maximum should not be set. self.assertIsNone(importer.do_import(), 'do_import should return None when import_source is not a list') self.assertEqual(mocked_import_wizard.progress_bar.setMaximum.called, False, 'setMaximum on import_wizard.progress_bar should not have been called')
def setUp(self): """ Set up the components need for all tests """ # Mocked out desktop object self.desktop = MagicMock() self.desktop.primaryScreen.return_value = SCREEN['primary'] self.desktop.screenCount.return_value = SCREEN['number'] self.desktop.screenGeometry.return_value = SCREEN['size'] self.screens = ScreenList.create(self.desktop) Registry.create()
def check_available_video_enabled_test(self): """ Test of webkit video availability """ # GIVEN: A WebkitPlayer instance and a mocked QWebPage mocked_qwebpage = MagicMock() mocked_qwebpage.mainFrame( ).evaluateJavaScript.return_value = '[object HTMLVideoElement]' with patch('openlp.core.ui.media.webkitplayer.QtWebKit.QWebPage', **{'return_value': mocked_qwebpage}): webkit_player = WebkitPlayer(None) # WHEN: An checking if the player is available available = webkit_player.check_available() # THEN: The player should be available when '[object HTMLVideoElement]' is returned self.assertEqual( True, available, 'The WebkitPlayer should be available when video feature detection passes' )
def test_detect_chorus(self, mocked_songimport): """ Test importing lyrics with a chorus in OPS Pro """ # GIVEN: A mocked out SongImport class, a mocked out "manager" and a mocked song and lyrics entry mocked_manager = MagicMock() importer = OPSProImport(mocked_manager, filenames=[]) importer.finish = MagicMock() song, lyrics = _build_data('you are so faithfull.txt', False) # WHEN: An importer object is created importer.process_song(song, lyrics, []) # THEN: The imported data should look like expected result_file = open(os.path.join(TEST_PATH, 'You are so faithful.json'), 'rb') result_data = json.loads(result_file.read().decode()) self.assertListEqual(importer.verses, _get_item(result_data, 'verses')) self.assertListEqual(importer.verse_order_list_generated, _get_item(result_data, 'verse_order_list'))
def build_lyrics_css_test(self): """ Test the build_lyrics_css() function """ # GIVEN: Mocked method and arguments. with patch('openlp.core.lib.htmlbuilder.build_lyrics_format_css') as mocked_build_lyrics_format_css, \ patch('openlp.core.lib.htmlbuilder.build_lyrics_outline_css') as mocked_build_lyrics_outline_css: mocked_build_lyrics_format_css.return_value = 'lyrics_format_css' mocked_build_lyrics_outline_css.return_value = '' item = MagicMock() item.main = QtCore.QRect(10, 20, 10, 20) item.theme_data.font_main_shadow = True item.theme_data.font_main_shadow_color = '#000000' item.theme_data.font_main_shadow_size = 5 # WHEN: Create the css. css = build_lyrics_css(item) # THEN: The css should be equal. self.assertEqual(LYRICS_CSS, css, 'The lyrics css should be equal.')