def test_remote_previous(self): """ Test service manager receives remote previous click properly (bug 1407445) """ # GIVEN: initial setup and mocks self.router.routes = [(r'^/api/service/(.*)$', { 'function': self.router.service, 'secure': False })] self.router.request_data = False mocked_previous_item = MagicMock() self.service_manager.previous_item = mocked_previous_item with patch.object(self.service_manager, 'setup_ui'), \ patch.object(self.router, 'do_json_header'): self.service_manager.bootstrap_initialise() self.app.processEvents() # WHEN: Remote next is received self.router.service(action='previous') self.app.processEvents() # THEN: service_manager.next_item() should have been called self.assertTrue( mocked_previous_item.called, 'previous_item() should have been called in service_manager')
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 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_play_is_preview(self, mocked_functools): """ Test the play() method of the SystemPlayer on the preview display """ # GIVEN: A SystemPlayer instance and a mocked display mocked_functools.partial.return_value = 'function' player = SystemPlayer(self) mocked_display = MagicMock() mocked_display.controller.is_live = False mocked_display.controller.media_info.start_time = 1 mocked_display.controller.media_info.volume = 1 # WHEN: play() is called with patch.object(player, 'get_preview_state') as mocked_get_preview_state, \ patch.object(player, 'seek') as mocked_seek, \ patch.object(player, 'volume') as mocked_volume, \ patch.object(player, 'set_state') as mocked_set_state: mocked_get_preview_state.return_value = QtMultimedia.QMediaPlayer.PlayingState result = player.play(mocked_display) # THEN: the media file is played mocked_get_preview_state.assert_called_once_with() mocked_display.media_player.play.assert_called_once_with() mocked_seek.assert_called_once_with(mocked_display, 1000) mocked_volume.assert_called_once_with(mocked_display, 1) mocked_display.media_player.durationChanged.connect.assert_called_once_with('function') mocked_set_state.assert_called_once_with(MediaState.Playing, mocked_display) mocked_display.video_widget.raise_.assert_called_once_with() self.assertTrue(result)
def test_do_import_breaks_on_stop(self, mocked_pyodbc): """ Test the MediaShoutImport do_import stops when the user presses the cancel button """ SongRecord = namedtuple( 'SongRecord', 'Record, Title, Author, Copyright, SongID, CCLI, Notes') song = SongRecord(1, 'Amazing Grace', 'William Wilberforce', 'Public Domain', 1, '654321', '') # GIVEN: A MediaShoutImport instance and a bunch of stuff mocked out importer = MediaShoutImport(MagicMock(), filename='mediashout.db') mocked_cursor = MagicMock() mocked_cursor.fetchall.return_value = [song] mocked_connection = MagicMock() mocked_connection.cursor.return_value = mocked_cursor mocked_pyodbc.connect.return_value = mocked_connection # WHEN: do_import is called, but cancelled with patch.object(importer, 'import_wizard') as mocked_import_wizard, \ patch.object(importer, 'process_song') as mocked_process_song: importer.stop_import_flag = True importer.do_import() # THEN: The songs should have been imported mocked_cursor.execute.assert_called_once_with( 'SELECT Record, Title, Author, Copyright, SongID, CCLI, Notes FROM Songs ORDER BY Title' ) mocked_process_song.assert_not_called()
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 process_chapters_verse_in_chapter_verse_milestone_test(self): """ Test process_chapters when supplied with an etree element with a verse element nested, when the verse system is based on milestones """ with patch('openlp.plugins.bibles.lib.importers.osis.verse_in_chapter', return_value=True), \ patch('openlp.plugins.bibles.lib.importers.osis.text_in_verse', return_value=False), \ patch.object(OSISBible, 'set_current_chapter') as mocked_set_current_chapter, \ patch.object(OSISBible, 'process_verse') as mocked_process_verse: # GIVEN: Some test data and an instance of OSISBible test_book = MagicMock() test_verse = MagicMock() test_verse.tail = '\n ' # Whitespace test_verse.text = 'Verse Text' test_chapter = MagicMock() test_chapter.__iter__.return_value = [test_verse] test_chapter.get.side_effect = lambda x: { 'osisID': '1.2.4', 'sID': '999' }.get(x) importer = OSISBible(MagicMock(), path='.', name='.', filename='') # WHEN: Calling process_chapters importer.process_chapters(test_book, [test_chapter]) # THEN: set_current_chapter and process_verse should have been called with the test data mocked_set_current_chapter.assert_called_once_with( test_book.name, 2) mocked_process_verse.assert_called_once_with(test_book, 2, test_verse, use_milestones=True)
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 test_start_over_1000_songs(self, mocked_translate): """ Test the start() method of the SearchWorker class when it finds over 1000 songs """ # GIVEN: An importer mock object, some search text and an initialised SearchWorker mocked_translate.side_effect = lambda x, y: y importer = MagicMock() importer.search.return_value = ['song%s' % num for num in range(1050)] search_text = 'Jesus' worker = SearchWorker(importer, search_text) # WHEN: The start() method is called with patch.object(worker, 'finished') as mocked_finished, patch.object(worker, 'quit') as mocked_quit, \ patch.object(worker, 'show_info') as mocked_show_info: worker.start() # THEN: The "finished" and "quit" signals should be emitted importer.search.assert_called_with(search_text, 1000, worker._found_song_callback) mocked_show_info.emit.assert_called_with( 'More than 1000 results', 'Your search has returned more than 1000 ' 'results, it has been stopped. Please ' 'refine your search to fetch better ' 'results.') mocked_finished.emit.assert_called_with() mocked_quit.emit.assert_called_with()
def get_language_accepted_test(self): """ Test the BibleImport.get_language method when the user accepts the dialog box """ # GIVEN: A mocked LanguageForm with an exec method which returns QtDialog.Accepted an instance of BibleDB and # a combobox with the selected item data as 10 with patch.object(BibleDB, 'save_meta'), patch.object(BibleDB, '_setup'), \ patch('openlp.plugins.bibles.forms.LanguageForm') as mocked_language_form: # The integer value of QtDialog.Accepted is 1. Using the enumeration causes a seg fault for some reason mocked_language_form_instance = MagicMock(**{'exec.return_value': 1, 'language_combo_box.itemData.return_value': 10}) mocked_language_form.return_value = mocked_language_form_instance instance = BibleImport(MagicMock()) mocked_wizard = MagicMock() instance.wizard = mocked_wizard # WHEN: Calling get_language() result = instance.get_language('Bible Name') # THEN: get_language() should return the id of the selected language in the combo box mocked_language_form.assert_called_once_with(mocked_wizard) mocked_language_form_instance.exec.assert_called_once_with('Bible Name') self.assertEqual(result, 10, 'get_language() should return the id of the language the user has chosen when ' 'they accept the dialog box')
def test_update_ui(self): """ Test the update_ui() method on the SystemPlayer """ # GIVEN: A SystemPlayer instance player = SystemPlayer(self) player.state = MediaState.Playing mocked_display = MagicMock() mocked_display.media_player.state.return_value = QtMultimedia.QMediaPlayer.PausedState mocked_display.controller.media_info.end_time = 1 mocked_display.media_player.position.return_value = 2 mocked_display.controller.seek_slider.isSliderDown.return_value = False # WHEN: update_ui() is called with patch.object(player, 'stop') as mocked_stop, \ patch.object(player, 'set_visible') as mocked_set_visible: player.update_ui(mocked_display) # THEN: The UI is updated expected_stop_calls = [call(mocked_display), call(mocked_display)] expected_position_calls = [call(), call()] expected_block_signals_calls = [call(True), call(False)] mocked_display.media_player.state.assert_called_once_with() self.assertEqual(2, mocked_stop.call_count) self.assertEqual(expected_stop_calls, mocked_stop.call_args_list) self.assertEqual(2, mocked_display.media_player.position.call_count) self.assertEqual(expected_position_calls, mocked_display.media_player.position.call_args_list) mocked_set_visible.assert_called_once_with(mocked_display, False) mocked_display.controller.seek_slider.isSliderDown.assert_called_once_with() self.assertEqual(expected_block_signals_calls, mocked_display.controller.seek_slider.blockSignals.call_args_list) mocked_display.controller.seek_slider.setSliderPosition.assert_called_once_with(2)
def test_do_import_breaks_on_stop(self, mocked_pyodbc): """ Test the MediaShoutImport do_import stops when the user presses the cancel button """ SongRecord = namedtuple('SongRecord', 'Record, Title, Author, Copyright, SongID, CCLI, Notes') song = SongRecord(1, 'Amazing Grace', 'William Wilberforce', 'Public Domain', 1, '654321', '') # GIVEN: A MediaShoutImport instance and a bunch of stuff mocked out importer = MediaShoutImport(MagicMock(), filename='mediashout.db') mocked_cursor = MagicMock() mocked_cursor.fetchall.return_value = [song] mocked_connection = MagicMock() mocked_connection.cursor.return_value = mocked_cursor mocked_pyodbc.connect.return_value = mocked_connection # WHEN: do_import is called, but cancelled with patch.object(importer, 'import_wizard') as mocked_import_wizard, \ patch.object(importer, 'process_song') as mocked_process_song: importer.stop_import_flag = True importer.do_import() # THEN: The songs should have been imported mocked_cursor.execute.assert_called_once_with( 'SELECT Record, Title, Author, Copyright, SongID, CCLI, Notes FROM Songs ORDER BY Title') mocked_process_song.assert_not_called()
def test_update_ui_dvd(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 process_chapters_milestones_verse_tag_test(self): """ Test process_chapters when supplied with an etree element with a chapter and verse element in the milestone configuration, where the verse is the "opening" milestone. (Has the sID attribute) """ with patch('openlp.plugins.bibles.lib.importers.osis.verse_in_chapter', return_value=False), \ patch.object(OSISBible, 'set_current_chapter') as mocked_set_current_chapter, \ patch.object(OSISBible, 'process_verse') as mocked_process_verse: # GIVEN: Some test data and an instance of OSISBible test_book = MagicMock() test_verse = MagicMock() test_verse.get.side_effect = lambda x: { 'osisID': '1.2.4', 'sID': '999' }.get(x) test_verse.tag = '{http://www.bibletechnologies.net/2003/OSIS/namespace}verse' test_verse.tail = '\n ' # Whitespace test_verse.text = 'Verse Text' # WHEN: Calling process_chapters importer = OSISBible(MagicMock(), path='.', name='.', filename='') importer.process_chapters(test_book, [test_verse]) # THEN: process_verse should have been called with the test data self.assertFalse(mocked_set_current_chapter.called) mocked_process_verse.assert_called_once_with(test_book, 0, test_verse, use_milestones=True)
def get_language_accepted_test(self): """ Test the BibleImport.get_language method when the user accepts the dialog box """ # GIVEN: A mocked LanguageForm with an exec method which returns QtDialog.Accepted an instance of BibleDB and # a combobox with the selected item data as 10 with patch.object(BibleDB, 'save_meta'), patch.object(BibleDB, '_setup'), \ patch('openlp.plugins.bibles.forms.LanguageForm') as mocked_language_form: # The integer value of QtDialog.Accepted is 1. Using the enumeration causes a seg fault for some reason mocked_language_form_instance = MagicMock( **{ 'exec.return_value': 1, 'language_combo_box.itemData.return_value': 10 }) mocked_language_form.return_value = mocked_language_form_instance instance = BibleImport(MagicMock()) mocked_wizard = MagicMock() instance.wizard = mocked_wizard # WHEN: Calling get_language() result = instance.get_language('Bible Name') # THEN: get_language() should return the id of the selected language in the combo box mocked_language_form.assert_called_once_with(mocked_wizard) mocked_language_form_instance.exec.assert_called_once_with( 'Bible Name') self.assertEqual( result, 10, 'get_language() should return the id of the language the user has chosen when ' 'they accept the dialog box')
def test_play_media_wait_state_not_playing(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.set_state(MediaState.Paused, mocked_display) # 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 test_play_is_preview(self, mocked_functools): """ Test the play() method of the SystemPlayer on the preview display """ # GIVEN: A SystemPlayer instance and a mocked display mocked_functools.partial.return_value = 'function' player = SystemPlayer(self) mocked_display = MagicMock() mocked_display.controller.is_live = False mocked_display.controller.media_info.start_time = 1 mocked_display.controller.media_info.volume = 1 # WHEN: play() is called with patch.object(player, 'get_preview_state') as mocked_get_preview_state, \ patch.object(player, 'seek') as mocked_seek, \ patch.object(player, 'volume') as mocked_volume, \ patch.object(player, 'set_state') as mocked_set_state: mocked_get_preview_state.return_value = QtMultimedia.QMediaPlayer.PlayingState result = player.play(mocked_display) # THEN: the media file is played mocked_get_preview_state.assert_called_once_with() mocked_display.media_player.play.assert_called_once_with() mocked_seek.assert_called_once_with(mocked_display, 1000) mocked_volume.assert_called_once_with(mocked_display, 1) mocked_display.media_player.durationChanged.connect.assert_called_once_with( 'function') mocked_set_state.assert_called_once_with(MediaState.Playing, mocked_display) mocked_display.video_widget.raise_.assert_called_once_with() self.assertTrue(result)
def test_load_valid_media(self): """ Test the load() method of SystemPlayer with a valid media file """ # GIVEN: A SystemPlayer instance and a mocked display player = SystemPlayer(self) mocked_display = MagicMock() mocked_display.controller.media_info.volume = 1 mocked_display.controller.media_info.file_info.absoluteFilePath.return_value = '/path/to/file' # WHEN: The load() method is run with patch.object(player, 'check_media') as mocked_check_media, \ patch.object(player, 'volume') as mocked_volume: mocked_check_media.return_value = True result = player.load(mocked_display) # THEN: the file is sent to the video widget mocked_display.controller.media_info.file_info.absoluteFilePath.assert_called_once_with( ) mocked_check_media.assert_called_once_with('/path/to/file') mocked_display.media_player.setMedia.assert_called_once_with( QtMultimedia.QMediaContent( QtCore.QUrl.fromLocalFile('/path/to/file'))) mocked_volume.assert_called_once_with(mocked_display, 1) self.assertTrue(result)
def test_play(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.set_state(MediaState.Paused, mocked_display) # 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() mocked_volume.assert_called_with(mocked_display, 100) self.assertEqual(MediaState.Playing, vlc_player.get_live_state()) mocked_display.vlc_widget.raise_.assert_called_with() self.assertTrue(result, 'The value returned from play() should be True')
def test_do_import(self, mocked_pyodbc): """ Test the MediaShoutImport do_import method """ SongRecord = namedtuple( 'SongRecord', 'Record, Title, Author, Copyright, SongID, CCLI, Notes') VerseRecord = namedtuple('VerseRecord', 'Type, Number, Text') PlayOrderRecord = namedtuple('PlayOrderRecord', 'Type, Number, POrder') ThemeRecord = namedtuple('ThemeRecord', 'Name') GroupRecord = namedtuple('GroupRecord', 'Name') song = SongRecord(1, 'Amazing Grace', 'William Wilberforce', 'Public Domain', 1, '654321', '') verse = VerseRecord( 'Verse', 1, 'Amazing grace, how sweet the sound\nThat saved a wretch like me') play_order = PlayOrderRecord('Verse', 1, 1) theme = ThemeRecord('Grace') group = GroupRecord('Hymns') # GIVEN: A MediaShoutImport instance and a bunch of stuff mocked out importer = MediaShoutImport(MagicMock(), filename='mediashout.db') mocked_cursor = MagicMock() mocked_cursor.fetchall.side_effect = [[song], [verse], [play_order], [theme], [group]] mocked_cursor.tables.fetchone.return_value = True mocked_connection = MagicMock() mocked_connection.cursor.return_value = mocked_cursor mocked_pyodbc.connect.return_value = mocked_connection # WHEN: do_import is called with patch.object(importer, 'import_wizard') as mocked_import_wizard, \ patch.object(importer, 'process_song') as mocked_process_song: importer.do_import() # THEN: The songs should have been imported expected_execute_calls = [ call( 'SELECT Record, Title, Author, Copyright, SongID, CCLI, Notes FROM Songs ORDER BY Title' ), call( 'SELECT Type, Number, Text FROM Verses WHERE Record = ? ORDER BY Type, Number', 1.0), call( 'SELECT Type, Number, POrder FROM PlayOrder WHERE Record = ? ORDER BY POrder', 1.0), call( 'SELECT Name FROM Themes INNER JOIN SongThemes ON SongThemes.ThemeId = Themes.ThemeId ' 'WHERE SongThemes.Record = ?', 1.0), call( 'SELECT Name FROM Groups INNER JOIN SongGroups ON SongGroups.GroupId = Groups.GroupId ' 'WHERE SongGroups.Record = ?', 1.0) ] self.assertEqual(expected_execute_calls, mocked_cursor.execute.call_args_list) mocked_process_song.assert_called_once_with(song, [verse], [play_order], [theme, group])
def test_on_save_report_button_clicked( self, mocked_qt, mocked_save_filename, mocked_python_version, mocked_platform, mocked_is_linux, mocked_etree, mocked_bs4, mocked_sqlalchemy, mocked_application_version, mocked_openlurl, mocked_qversion, ): """ Test save report saves the correct information to a file """ mocked_etree.__version__ = 'ETree Test' mocked_bs4.__version__ = 'BeautifulSoup Test' mocked_sqlalchemy.__version__ = 'SqlAlchemy Test' mocked_python_version.return_value = 'Python Test' mocked_platform.return_value = 'Nose Test' mocked_qversion.return_value = 'Qt5 test' mocked_qt.PYQT_VERSION_STR = 'PyQt5 Test' mocked_is_linux.return_value = False mocked_application_version.return_value = 'Trunk Test' mocked_save_filename.return_value = [ 'testfile.txt', ] test_form = exceptionform.ExceptionForm() test_form.file_attachment = None with patch.object(test_form, '_pyuno_import') as mock_pyuno: with patch.object(test_form.exception_text_edit, 'toPlainText') as mock_traceback: with patch.object(test_form.description_text_edit, 'toPlainText') as mock_description: with patch("openlp.core.ui.exceptionform.open", mock_open(), create=True) as mocked_open: mock_pyuno.return_value = 'UNO Bridge Test' mock_traceback.return_value = 'openlp: Traceback Test' mock_description.return_value = 'Description Test' # WHEN: on_save_report_button_clicked called test_form.on_save_report_button_clicked() # THEN: Verify proper calls to save file # self.maxDiff = None check_text = "call().write({text})".format( text=MAIL_ITEM_TEXT.__repr__()) write_text = "{text}".format(text=mocked_open.mock_calls[1]) mocked_open.assert_called_with('testfile.txt', 'w') self.assertEquals(check_text, write_text, "Saved information should match test text")
def test_on_send_report_button_clicked( self, mocked_qt, mocked_add_query_item, mocked_qurl, mocked_file_dialog, mocked_ui_exception_dialog, mocked_python_version, mocked_platform, mocked_is_linux, mocked_etree, mocked_bs4, mocked_sqlalchemy, mocked_application_version, mocked_openlurl, mocked_qversion, ): """ Test send report creates the proper system information text """ # GIVEN: Test environment mocked_etree.__version__ = 'ETree Test' mocked_bs4.__version__ = 'BeautifulSoup Test' mocked_sqlalchemy.__version__ = 'SqlAlchemy Test' mocked_python_version.return_value = 'Python Test' mocked_platform.return_value = 'Nose Test' mocked_qversion.return_value = 'Qt5 test' mocked_is_linux.return_value = False mocked_application_version.return_value = 'Trunk Test' mocked_qt.PYQT_VERSION_STR = 'PyQt5 Test' mocked_is_linux.return_value = False mocked_application_version.return_value = 'Trunk Test' test_form = exceptionform.ExceptionForm() test_form.file_attachment = None with patch.object(test_form, '_pyuno_import') as mock_pyuno: with patch.object(test_form.exception_text_edit, 'toPlainText') as mock_traceback: with patch.object(test_form.description_text_edit, 'toPlainText') as mock_description: mock_pyuno.return_value = 'UNO Bridge Test' mock_traceback.return_value = 'openlp: Traceback Test' mock_description.return_value = 'Description Test' # WHEN: on_save_report_button_clicked called test_form.on_send_report_button_clicked() # THEN: Verify strings were formatted properly mocked_add_query_item.assert_called_with('body', MAIL_ITEM_TEXT)
def validate_xml_file_success_test(self): """ Test that validate_xml_file returns True with valid XML """ # GIVEN: Some test data with an OpenSong Bible "bible" root tag with patch.object(BibleImport, 'parse_xml', return_value=objectify.fromstring('<bible></bible>')), \ patch.object(BibleImport, 'is_compressed', return_value=False): importer = BibleImport(MagicMock(), path='.', name='.', filename='') # WHEN: Calling validate_xml_file result = importer.validate_xml_file('file.name', 'bible') # THEN: True should be returned self.assertTrue(result)
def test_on_search_shortcut_triggered_shows_media_manager(self): """ Test that the media manager is made visible when the search shortcut is triggered """ # GIVEN: A build main window set up for testing with patch.object(self.main_window, 'media_manager_dock') as mocked_media_manager_dock, \ patch.object(self.main_window, 'media_tool_box') as mocked_media_tool_box: mocked_media_manager_dock.isVisible.return_value = False mocked_media_tool_box.currentWidget.return_value = None # WHEN: The search shortcut is triggered self.main_window.on_search_shortcut_triggered() # THEN: The media manager dock is made visible mocked_media_manager_dock.setVisible.assert_called_with(True)
def validate_xml_file_parse_xml_fails_test(self): """ Test that validate_xml_file raises a ValidationError when parse_xml returns None """ # GIVEN: A mocked parse_xml which returns None with patch.object(BibleImport, 'parse_xml', return_value=None), \ patch.object(BibleImport, 'is_compressed', return_value=False): importer = BibleImport(MagicMock(), path='.', name='.', filename='') # WHEN: Calling validate_xml_file # THEN: ValidationError should be raised, with the message 'Error when opening file' # the user that an OpenSong bible was found with self.assertRaises(ValidationError) as context: importer.validate_xml_file('file.name', 'xbible') self.assertEqual(context.exception.msg, 'Error when opening file')
def test_on_search_results_widget_selection_changed(self): """ Test that the view button is updated when the search results list is changed """ # GIVEN: A SongSelect form ssform = SongSelectForm(None, MagicMock(), MagicMock()) # WHEN: There is at least 1 item selected with patch.object(ssform, 'search_results_widget') as mocked_search_results_widget, \ patch.object(ssform, 'view_button') as mocked_view_button: mocked_search_results_widget.selectedItems.return_value = [1] ssform.on_search_results_widget_selection_changed() # THEN: The view button should be enabled mocked_view_button.setEnabled.assert_called_with(True)
def test_on_back_button_clicked(self): """ Test that when the back button is clicked, the stacked widget is set back one page """ # GIVEN: A SongSelect form ssform = SongSelectForm(None, MagicMock(), MagicMock()) # WHEN: The back button is clicked with patch.object(ssform, 'stacked_widget') as mocked_stacked_widget, \ patch.object(ssform, 'search_combobox') as mocked_search_combobox: ssform.on_back_button_clicked() # THEN: The stacked widget should be set back one page mocked_stacked_widget.setCurrentIndex.assert_called_with(1) mocked_search_combobox.setFocus.assert_called_with()
def parse_xml_file_permission_error_exception_test(self): """ Test that parse_xml handles a PermissionError exception correctly """ with patch.object(BibleImport, 'log_exception') as mocked_log_exception: # GIVEN: A mocked open which raises a PermissionError and an instance of BibleImporter exception = PermissionError() exception.filename = 'file.tst' exception.strerror = 'Permission denied' self.mocked_open.side_effect = exception importer = BibleImport(MagicMock(), path='.', name='.', filename='') # WHEN: Calling parse_xml result = importer.parse_xml('file.tst') # THEN: parse_xml should have caught the error, informed the user and returned None mocked_log_exception.assert_called_once_with( 'Opening file.tst failed.') self.mocked_critical_error_message_box.assert_called_once_with( title='An Error Occured When Opening A File', message= 'The following error occurred when trying to open\nfile.tst:\n\nPermission denied' ) self.assertIsNone(result)
def test_signals_error(self): """ Test the signals() signal of the CheckMediaWorker class with a "error" origin """ # GIVEN: A CheckMediaWorker instance worker = CheckMediaWorker('file.ogv') # WHEN: signals() is called with error and BufferedMedia with patch.object(worker, 'stop') as mocked_stop, \ patch.object(worker, 'finished') as mocked_finished: worker.signals('error', None) # THEN: The worker should exit and the result should be True mocked_stop.assert_called_once_with() mocked_finished.emit.assert_called_once_with() self.assertFalse(worker.result)
def test_on_cancel_button_clicked(self): """ Test that the cancel button click slot shuts down the threads correctly """ # GIVEN: A FRW, some mocked threads and workers (that isn't quite done) and other mocked stuff frw = FirstTimeForm(None) frw.initialize(MagicMock()) mocked_worker = MagicMock() mocked_thread = MagicMock() mocked_thread.isRunning.side_effect = [True, False] frw.theme_screenshot_workers.append(mocked_worker) frw.theme_screenshot_threads.append(mocked_thread) with patch('openlp.core.ui.firsttimeform.time') as mocked_time, \ patch.object(frw.application, 'set_normal_cursor') as mocked_set_normal_cursor: # WHEN: on_cancel_button_clicked() is called frw.on_cancel_button_clicked() # THEN: The right things should be called in the right order self.assertTrue(frw.was_cancelled, 'The was_cancelled property should have been set to True') mocked_worker.set_download_canceled.assert_called_with(True) mocked_thread.isRunning.assert_called_with() self.assertEqual(2, mocked_thread.isRunning.call_count, 'isRunning() should have been called twice') mocked_time.sleep.assert_called_with(0.1) self.assertEqual(1, mocked_time.sleep.call_count, 'sleep() should have only been called once') mocked_set_normal_cursor.assert_called_with()
def process_books_completes_test(self): """ Test process_books when it processes all books """ # GIVEN: An instance of OpenSongBible Importer and two mocked books self.mocked_find_and_create_book.side_effect = ['db_book1', 'db_book2'] with patch.object(OpenSongBible, 'process_chapters') as mocked_process_chapters: importer = OpenSongBible(MagicMock(), path='.', name='.', filename='') book1 = MagicMock() book1.attrib = {'n': 'Name1'} book1.c = 'Chapter1' book2 = MagicMock() book2.attrib = {'n': 'Name2'} book2.c = 'Chapter2' importer.language_id = 10 importer.session = MagicMock() importer.stop_import_flag = False # WHEN: Calling process_books with the two books importer.process_books([book1, book2]) # THEN: find_and_create_book and process_books should be called with the details from the mocked books self.assertEqual(self.mocked_find_and_create_book.call_args_list, [call('Name1', 2, 10), call('Name2', 2, 10)]) self.assertEqual( mocked_process_chapters.call_args_list, [call('db_book1', 'Chapter1'), call('db_book2', 'Chapter2')]) self.assertEqual(importer.session.commit.call_count, 2)
def process_books_completes_test(self): """ Test process_books when it processes all books """ # GIVEN: An instance of OSISBible Importer and two mocked books self.mocked_find_and_create_book.side_effect = ['db_book1', 'db_book2'] with patch.object(OSISBible, 'process_chapters') as mocked_process_chapters: importer = OSISBible(MagicMock(), path='.', name='.', filename='') book1 = MagicMock() book1.get.return_value = 'Name1' book2 = MagicMock() book2.get.return_value = 'Name2' mocked_data = MagicMock(**{'xpath.return_value': [book1, book2]}) importer.language_id = 10 importer.session = MagicMock() importer.stop_import_flag = False # WHEN: Calling process_books with the two books importer.process_books(mocked_data) # THEN: find_and_create_book and process_books should be called with the details from the mocked books self.assertEqual(self.mocked_find_and_create_book.call_args_list, [call('Name1', 2, 10), call('Name2', 2, 10)]) self.assertEqual( mocked_process_chapters.call_args_list, [call('db_book1', book1), call('db_book2', book2)]) self.assertEqual(importer.session.commit.call_count, 2)
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 on_import_yes_clicked_test(self, mocked_translate, mocked_question): """ Test that when a song is imported and the user clicks the "yes" button, the UI goes back to the previous page """ # GIVEN: A valid SongSelectForm with a mocked out QMessageBox.question() method mocked_translate.side_effect = lambda *args: args[1] mocked_question.return_value = QtGui.QMessageBox.Yes ssform = SongSelectForm(None, MagicMock(), MagicMock()) mocked_song_select_importer = MagicMock() ssform.song_select_importer = mocked_song_select_importer ssform.song = None # WHEN: The import button is clicked, and the user clicks Yes with patch.object( ssform, 'on_back_button_clicked') as mocked_on_back_button_clicked: ssform.on_import_button_clicked() # THEN: The on_back_button_clicked() method should have been called mocked_song_select_importer.save_song.assert_called_with(None) mocked_question.assert_called_with( ssform, 'Song Imported', 'Your song has been imported, would you like to import more songs?', QtGui.QMessageBox.Yes | QtGui.QMessageBox.No, QtGui.QMessageBox.Yes) mocked_on_back_button_clicked.assert_called_with() self.assertIsNone(ssform.song)
def get_language_canceled_test(self): """ Test the BibleImport.get_language method when the user rejects the dialog box """ # GIVEN: A mocked LanguageForm with an exec method which returns QtDialog.Rejected and an instance of BibleDB with patch.object( BibleDB, '_setup'), patch('openlp.plugins.bibles.forms.LanguageForm' ) as mocked_language_form: # The integer value of QtDialog.Rejected is 0. Using the enumeration causes a seg fault for some reason mocked_language_form_instance = MagicMock( **{'exec.return_value': 0}) mocked_language_form.return_value = mocked_language_form_instance instance = BibleImport(MagicMock()) mocked_wizard = MagicMock() instance.wizard = mocked_wizard # WHEN: Calling get_language() result = instance.get_language() # THEN: get_language() should return False mocked_language_form.assert_called_once_with(mocked_wizard) mocked_language_form_instance.exec.assert_called_once_with(None) self.assertFalse( result, 'get_language() should return False if the user rejects the dialog box' )
def test_on_view_button_clicked(self): """ Test that a song is retrieved when the view button is clicked """ # GIVEN: A SongSelect form ssform = SongSelectForm(None, MagicMock(), MagicMock()) expected_song = {'title': 'Amazing Grace'} # WHEN: A song result is double-clicked with patch.object(ssform, '_view_song') as mocked_view_song, \ patch.object(ssform, 'search_results_widget') as mocked_search_results_widget: mocked_search_results_widget.currentItem.return_value = expected_song ssform.on_view_button_clicked() # THEN: The song is fetched and shown to the user mocked_view_song.assert_called_with(expected_song)
def test_on_import_no_clicked(self, mocked_translate, mocked_question): """ Test that when a song is imported and the user clicks the "no" button, the UI exits """ # GIVEN: A valid SongSelectForm with a mocked out QMessageBox.question() method mocked_translate.side_effect = lambda *args: args[1] mocked_question.return_value = QtWidgets.QMessageBox.No ssform = SongSelectForm(None, MagicMock(), MagicMock()) mocked_song_select_importer = MagicMock() ssform.song_select_importer = mocked_song_select_importer ssform.song = None # WHEN: The import button is clicked, and the user clicks Yes with patch.object(ssform, 'done') as mocked_done: ssform.on_import_button_clicked() # THEN: The on_back_button_clicked() method should have been called mocked_song_select_importer.save_song.assert_called_with(None) mocked_question.assert_called_with( ssform, 'Song Imported', 'Your song has been imported, would you like to import more songs?', QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No, QtWidgets.QMessageBox.Yes) mocked_done.assert_called_with(QtWidgets.QDialog.Accepted) self.assertIsNone(ssform.song)
def test_process_song_with_song_number(self): """ Test the process_song method with a song that has a song number """ # GIVEN: An importer and a song SongRecord = namedtuple( 'SongRecord', 'Record, Title, Author, Copyright, SongID, CCLI, Notes') VerseRecord = namedtuple('VerseRecord', 'Type, Number, Text') PlayOrderRecord = namedtuple('PlayOrderRecord', 'Type, Number, POrder') ThemeRecord = namedtuple('ThemeRecord', 'Name') GroupRecord = namedtuple('GroupRecord', 'Name') song = SongRecord(1, 'Amazing Grace', 'William Wilberforce', 'Public Domain', 'Hymns-2', '654321', 'Great old hymn') verse = VerseRecord( 0, 1, 'Amazing grace, how sweet the sound\nThat saved a wretch like me') play_order = PlayOrderRecord(0, 1, 1) theme = ThemeRecord('Grace') group = GroupRecord('Hymns') importer = MediaShoutImport(MagicMock(), filename='mediashout.db') # WHEN: A song is processed with patch.object(importer, 'set_defaults') as mocked_set_defaults, \ patch.object(importer, 'parse_author') as mocked_parse_author, \ patch.object(importer, 'add_copyright') as mocked_add_copyright, \ patch.object(importer, 'add_verse') as mocked_add_verse, \ patch.object(importer, 'finish') as mocked_finish: importer.topics = [] importer.verse_order_list = [] importer.process_song(song, [verse], [play_order], [theme, group]) # THEN: It should be added to the database mocked_set_defaults.assert_called_once_with() self.assertEqual('Amazing Grace', importer.title) mocked_parse_author.assert_called_once_with('William Wilberforce') mocked_add_copyright.assert_called_once_with('Public Domain') self.assertEqual('Great old hymn', importer.comments) self.assertEqual(['Grace', 'Hymns'], importer.topics) self.assertEqual('Hymns', importer.song_book_name) self.assertEqual('2', importer.song_number) mocked_add_verse.assert_called_once_with( 'Amazing grace, how sweet the sound\nThat saved a wretch like me', 'V1') self.assertEqual(['V1'], importer.verse_order_list) mocked_finish.assert_called_once_with()
def test_on_save_report_button_clicked(self, mocked_qt, mocked_save_filename, mocked_python_version, mocked_platform, mocked_is_linux, mocked_etree, mocked_bs4, mocked_sqlalchemy, mocked_application_version, mocked_openlurl, mocked_qversion, ): """ Test save report saves the correct information to a file """ mocked_etree.__version__ = 'ETree Test' mocked_bs4.__version__ = 'BeautifulSoup Test' mocked_sqlalchemy.__version__ = 'SqlAlchemy Test' mocked_python_version.return_value = 'Python Test' mocked_platform.return_value = 'Nose Test' mocked_qversion.return_value = 'Qt5 test' mocked_qt.PYQT_VERSION_STR = 'PyQt5 Test' mocked_is_linux.return_value = False mocked_application_version.return_value = 'Trunk Test' mocked_save_filename.return_value = ['testfile.txt', ] test_form = exceptionform.ExceptionForm() test_form.file_attachment = None with patch.object(test_form, '_pyuno_import') as mock_pyuno: with patch.object(test_form.exception_text_edit, 'toPlainText') as mock_traceback: with patch.object(test_form.description_text_edit, 'toPlainText') as mock_description: with patch("openlp.core.ui.exceptionform.open", mock_open(), create=True) as mocked_open: mock_pyuno.return_value = 'UNO Bridge Test' mock_traceback.return_value = 'openlp: Traceback Test' mock_description.return_value = 'Description Test' # WHEN: on_save_report_button_clicked called test_form.on_save_report_button_clicked() # THEN: Verify proper calls to save file # self.maxDiff = None check_text = "call().write({text})".format(text=MAIL_ITEM_TEXT.__repr__()) write_text = "{text}".format(text=mocked_open.mock_calls[1]) mocked_open.assert_called_with('testfile.txt', 'w') self.assertEquals(check_text, write_text, "Saved information should match test text")
def test_on_send_report_button_clicked(self, mocked_qt, mocked_add_query_item, mocked_qurl, mocked_file_dialog, mocked_ui_exception_dialog, mocked_python_version, mocked_platform, mocked_is_linux, mocked_etree, mocked_bs4, mocked_sqlalchemy, mocked_application_version, mocked_openlurl, mocked_qversion, ): """ Test send report creates the proper system information text """ # GIVEN: Test environment mocked_etree.__version__ = 'ETree Test' mocked_bs4.__version__ = 'BeautifulSoup Test' mocked_sqlalchemy.__version__ = 'SqlAlchemy Test' mocked_python_version.return_value = 'Python Test' mocked_platform.return_value = 'Nose Test' mocked_qversion.return_value = 'Qt5 test' mocked_is_linux.return_value = False mocked_application_version.return_value = 'Trunk Test' mocked_qt.PYQT_VERSION_STR = 'PyQt5 Test' mocked_is_linux.return_value = False mocked_application_version.return_value = 'Trunk Test' test_form = exceptionform.ExceptionForm() test_form.file_attachment = None with patch.object(test_form, '_pyuno_import') as mock_pyuno: with patch.object(test_form.exception_text_edit, 'toPlainText') as mock_traceback: with patch.object(test_form.description_text_edit, 'toPlainText') as mock_description: mock_pyuno.return_value = 'UNO Bridge Test' mock_traceback.return_value = 'openlp: Traceback Test' mock_description.return_value = 'Description Test' # WHEN: on_save_report_button_clicked called test_form.on_send_report_button_clicked() # THEN: Verify strings were formatted properly mocked_add_query_item.assert_called_with('body', MAIL_ITEM_TEXT)
def validate_xml_file_zefania_root_test(self): """ Test that validate_xml_file raises a ValidationError with an Zefania root tag """ # GIVEN: Some test data with an Zefania root tag and an instance of BibleImport with patch.object(BibleImport, 'parse_xml', return_value=objectify.fromstring('<xmlbible></xmlbible>')), \ patch.object(BibleImport, 'is_compressed', return_value=False): importer = BibleImport(MagicMock(), path='.', name='.', filename='') # WHEN: Calling validate_xml_file # THEN: ValidationError should be raised, and the critical error message box should was called informing # the user that an Zefania bible was found with self.assertRaises(ValidationError) as context: importer.validate_xml_file('file.name', 'xbible') self.assertEqual(context.exception.msg, 'Invalid xml.') self.mocked_critical_error_message_box.assert_called_once_with( message='Incorrect Bible file type supplied. This looks like an Zefania XML bible.')
def test_on_search_shortcut_triggered_focuses_widget(self): """ Test that the focus is set on the widget when the search shortcut is triggered """ # GIVEN: A build main window set up for testing with patch.object(self.main_window, 'media_manager_dock') as mocked_media_manager_dock, \ patch.object(self.main_window, 'media_tool_box') as mocked_media_tool_box: mocked_media_manager_dock.isVisible.return_value = True mocked_widget = MagicMock() mocked_media_tool_box.currentWidget.return_value = mocked_widget # WHEN: The search shortcut is triggered self.main_window.on_search_shortcut_triggered() # THEN: The media manager dock is made visible self.assertEqual(0, mocked_media_manager_dock.setVisible.call_count) mocked_widget.on_focus.assert_called_with()
def do_import_completes_test(self): """ Test do_import when it completes successfully """ # GIVEN: An instance of OpenSongBible with patch.object(OSISBible, 'log_debug'), \ patch.object(OSISBible, 'validate_xml_file'), \ patch.object(OSISBible, 'parse_xml'), \ patch.object(OSISBible, 'get_language_id', **{'return_value': 10}), \ patch.object(OSISBible, 'process_books'): importer = OSISBible(MagicMock(), path='.', name='.', filename='') # WHEN: Calling do_import result = importer.do_import() # THEN: do_import should return True self.assertTrue(result)
def insert_tab_not_visible_test(self): """ Test that the insert_tab() method works correctly when a tab that should not be visible is inserted """ # GIVEN: A general tab and a Settings Form settings_form = SettingsForm(None) general_tab = MagicMock() general_tab.tab_title = 'mock' # 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=False) # THEN: The general tab should have been inserted, but no list item should have been inserted into the list mocked_add_widget.assert_called_with(general_tab) self.assertEqual(0, mocked_add_item.call_count, 'addItem should not have been called')
def test_stop(self): """ Test the stop() method of the SystemPlayer """ # GIVEN: A SystemPlayer instance player = SystemPlayer(self) mocked_display = MagicMock() # WHEN: The stop method is called with patch.object(player, 'set_visible') as mocked_set_visible, \ patch.object(player, 'set_state') as mocked_set_state: player.stop(mocked_display) # THEN: The video is stopped mocked_display.media_player.stop.assert_called_once_with() mocked_set_visible.assert_called_once_with(mocked_display, False) mocked_set_state.assert_called_once_with(MediaState.Stopped, mocked_display)
def test_start(self): """ Test the start() method of the SearchWorker class """ # GIVEN: An importer mock object, some search text and an initialised SearchWorker importer = MagicMock() importer.search.return_value = ['song1', 'song2'] search_text = 'Jesus' worker = SearchWorker(importer, search_text) # WHEN: The start() method is called with patch.object(worker, 'finished') as mocked_finished, patch.object(worker, 'quit') as mocked_quit: worker.start() # THEN: The "finished" and "quit" signals should be emitted importer.search.assert_called_with(search_text, 1000, worker._found_song_callback) mocked_finished.emit.assert_called_with() mocked_quit.emit.assert_called_with()
def remote_previous_test(self): """ Test service manager receives remote previous click properly (bug 1407445) """ # GIVEN: initial setup and mocks self.router.routes = [(r"^/api/service/(.*)$", {"function": self.router.service, "secure": False})] self.router.request_data = False mocked_previous_item = MagicMock() self.service_manager.previous_item = mocked_previous_item with patch.object(self.service_manager, "setup_ui"), patch.object(self.router, "do_json_header"): self.service_manager.bootstrap_initialise() self.app.processEvents() # WHEN: Remote next is received self.router.service(action="previous") self.app.processEvents() # THEN: service_manager.next_item() should have been called self.assertTrue(mocked_previous_item.called, "previous_item() should have been called in service_manager")
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_pause_is_preview(self): """ Test the pause() method of the SystemPlayer on the preview display """ # GIVEN: A SystemPlayer instance player = SystemPlayer(self) mocked_display = MagicMock() mocked_display.controller.is_live = False # WHEN: The pause method is called with patch.object(player, 'get_preview_state') as mocked_get_preview_state, \ patch.object(player, 'set_state') as mocked_set_state: mocked_get_preview_state.return_value = QtMultimedia.QMediaPlayer.PausedState player.pause(mocked_display) # THEN: The video is paused mocked_display.media_player.pause.assert_called_once_with() mocked_get_preview_state.assert_called_once_with() mocked_set_state.assert_called_once_with(MediaState.Paused, mocked_display)
def test_reset(self): """ Test the reset() method of the SystemPlayer """ # GIVEN: A SystemPlayer instance player = SystemPlayer(self) mocked_display = MagicMock() # WHEN: reset() is called with patch.object(player, 'set_state') as mocked_set_state, \ patch.object(player, 'set_visible') as mocked_set_visible: player.reset(mocked_display) # THEN: The media player is reset mocked_display.media_player.stop() mocked_display.media_player.setMedia.assert_called_once_with(QtMultimedia.QMediaContent()) mocked_set_visible.assert_called_once_with(mocked_display, False) mocked_display.video_widget.setVisible.assert_called_once_with(False) mocked_set_state.assert_called_once_with(MediaState.Off, mocked_display)
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 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')