diff --git a/openlp/core/common/settings.py b/openlp/core/common/settings.py index 18c7dfe29..923f5dd3f 100644 --- a/openlp/core/common/settings.py +++ b/openlp/core/common/settings.py @@ -291,6 +291,8 @@ class Settings(QtCore.QSettings): 'media/vlc arguments': '', 'media/live volume': 50, 'media/preview volume': 0, + 'media/live loop': False, + 'media/preview loop': False, 'media/db type': 'sqlite', 'media/db username': '', 'media/db password': '', diff --git a/openlp/core/ui/media/__init__.py b/openlp/core/ui/media/__init__.py index ee3ad71c5..a47dd3c20 100644 --- a/openlp/core/ui/media/__init__.py +++ b/openlp/core/ui/media/__init__.py @@ -23,6 +23,8 @@ The :mod:`~openlp.core.ui.media` module contains classes and objects for media p """ import logging +from openlp.core.common.registry import Registry + log = logging.getLogger(__name__ + '.__init__') # Audio and video extensions copied from 'include/vlc_interface.h' from vlc 2.2.0 source @@ -83,9 +85,7 @@ class ItemMediaInfo(object): This class hold the media related info """ file_info = None - volume = 100 is_background = False - is_looping_playback = False length = 0 start_time = 0 end_time = 0 @@ -97,6 +97,57 @@ class ItemMediaInfo(object): media_type = MediaType() +def get_volume(controller) -> int: + """ + The volume needs to be retrieved + + :param controller: the controller in use + :return: Are we looping + """ + if controller.is_live: + return Registry().get('settings').value('media/live volume') + else: + return Registry().get('settings').value('media/preview volume') + + +def save_volume(controller, volume: int) -> None: + """ + The volume needs to be saved + + :param controller: the controller in use + :param volume: The volume to use and save + :return: Are we looping + """ + if controller.is_live: + return Registry().get('settings').setValue('media/live volume', volume) + else: + return Registry().get('settings').setValue('media/preview volume', volume) + + +def is_looping_playback(controller) -> bool: + """ + :param controller: the controller in use + :return: Are we looping + """ + if controller.is_live: + return Registry().get('settings').value('media/live loop') + else: + return Registry().get('settings').value('media/preview loop') + + +def toggle_looping_playback(controller) -> None: + """ + + :param controller: the controller in use + :return: None + """ + if controller.is_live: + Registry().get('settings').setValue('media/live loop', not Registry().get('settings').value('media/live loop')) + else: + Registry().get('settings').setValue('media/preview loop', + not Registry().get('settings').value('media/preview loop')) + + def parse_optical_path(input_string): """ Split the optical path info. diff --git a/openlp/core/ui/media/mediacontroller.py b/openlp/core/ui/media/mediacontroller.py index 19422a7bd..23b10d9e2 100644 --- a/openlp/core/ui/media/mediacontroller.py +++ b/openlp/core/ui/media/mediacontroller.py @@ -42,7 +42,8 @@ from openlp.core.lib.serviceitem import ItemCapabilities from openlp.core.lib.ui import critical_error_message_box from openlp.core.state import State from openlp.core.ui import DisplayControllerType, HideMode -from openlp.core.ui.media import MediaState, ItemMediaInfo, MediaType, parse_optical_path, parse_stream_path +from openlp.core.ui.media import MediaState, ItemMediaInfo, MediaType, parse_optical_path, parse_stream_path, \ + get_volume, toggle_looping_playback, is_looping_playback, save_volume from openlp.core.ui.media.remote import register_views from openlp.core.ui.media.vlcplayer import VlcPlayer, get_vlc @@ -236,10 +237,6 @@ class MediaController(RegistryBase, LogMixin, RegistryProperties): self.media_reset(controller) controller.media_info = ItemMediaInfo() controller.media_info.media_type = MediaType.Video - if controller.is_live: - controller.media_info.volume = self.settings.value('media/live volume') - else: - controller.media_info.volume = self.settings.value('media/preview volume') # background will always loop video. if service_item.is_capable(ItemCapabilities.HasBackgroundAudio): controller.media_info.file_info = [file_path for (file_path, file_hash) in service_item.background_audio] @@ -255,7 +252,6 @@ class MediaController(RegistryBase, LogMixin, RegistryProperties): elif service_item.is_capable(ItemCapabilities.HasBackgroundVideo): controller.media_info.file_info = [service_item.video_file_name] service_item.media_length = self.media_length(service_item.video_file_name) - controller.media_info.is_looping_playback = True controller.media_info.is_background = True else: controller.media_info.file_info = [service_item.get_frame_path()] @@ -457,13 +453,13 @@ class MediaController(RegistryBase, LogMixin, RegistryProperties): controller.seek_slider.blockSignals(False) controller.volume_slider.blockSignals(False) return False - self.media_volume(controller, controller.media_info.volume) + self.media_volume(controller, get_volume(controller)) if not start_hidden: self._media_set_visibility(controller, True) controller.mediabar.actions['playbackPlay'].setVisible(False) controller.mediabar.actions['playbackPause'].setVisible(True) controller.mediabar.actions['playbackStop'].setDisabled(False) - controller.mediabar.actions['playbackLoop'].setChecked(controller.media_info.is_looping_playback) + controller.mediabar.actions['playbackLoop'].setChecked(is_looping_playback(controller)) controller.mediabar.actions['playbackStop'].setVisible(not controller.media_info.is_background or controller.media_info.media_type is MediaType.Audio) controller.mediabar.actions['playbackLoop'].setVisible((not controller.media_info.is_background and @@ -501,7 +497,7 @@ class MediaController(RegistryBase, LogMixin, RegistryProperties): if controller.media_info.is_playing and controller.media_info.length > 0: controller.media_info.timer += TICK_TIME if controller.media_info.timer >= controller.media_info.start_time + controller.media_info.length: - if controller.media_info.is_looping_playback: + if is_looping_playback(controller): start_again = True else: self.media_stop(controller) @@ -522,8 +518,11 @@ class MediaController(RegistryBase, LogMixin, RegistryProperties): end_seconds = controller.media_info.end_time // 1000 end_minutes = end_seconds // 60 end_seconds %= 60 - controller.position_label.setText(' %02d:%02d / %02d:%02d' % - (minutes, seconds, end_minutes, end_seconds)) + if end_minutes == 0 and end_seconds == 0: + controller.position_label.setText('') + else: + controller.position_label.setText(' %02d:%02d / %02d:%02d' % + (minutes, seconds, end_minutes, end_seconds)) def media_pause_msg(self, msg): """ @@ -573,8 +572,8 @@ class MediaController(RegistryBase, LogMixin, RegistryProperties): :param controller: The controller that needs to be stopped """ - controller.media_info.is_looping_playback = not controller.media_info.is_looping_playback - controller.mediabar.actions['playbackLoop'].setChecked(controller.media_info.is_looping_playback) + toggle_looping_playback(controller) + controller.mediabar.actions['playbackLoop'].setChecked(is_looping_playback(controller)) def media_stop_msg(self, msg): """ @@ -638,11 +637,7 @@ class MediaController(RegistryBase, LogMixin, RegistryProperties): :param volume: The volume to be set """ self.log_debug(f'media_volume {volume}') - if controller.is_live: - self.settings.setValue('media/live volume', volume) - else: - self.settings.setValue('media/preview volume', volume) - controller.media_info.volume = volume + save_volume(controller, volume) self.current_media_players[controller.controller_type].volume(controller, volume) controller.volume_slider.setValue(volume) diff --git a/openlp/core/ui/media/vlcplayer.py b/openlp/core/ui/media/vlcplayer.py index 660d81829..b3c06ebd1 100644 --- a/openlp/core/ui/media/vlcplayer.py +++ b/openlp/core/ui/media/vlcplayer.py @@ -35,13 +35,11 @@ from openlp.core.common.i18n import translate from openlp.core.common.platform import is_linux, is_macosx, is_win from openlp.core.display.screens import ScreenList from openlp.core.lib.ui import critical_error_message_box -from openlp.core.ui.media import MediaState, MediaType, VlCState +from openlp.core.ui.media import MediaState, MediaType, VlCState, get_volume from openlp.core.ui.media.mediaplayer import MediaPlayer log = logging.getLogger(__name__) -# Audio and video extensions copied from 'include/vlc_interface.h' from vlc 2.2.0 source - STATE_WAIT_TIME = 60 @@ -229,7 +227,7 @@ class VlcPlayer(MediaPlayer): controller.vlc_media.parse() controller.seek_slider.setMinimum(controller.media_info.start_time) controller.seek_slider.setMaximum(controller.media_info.end_time) - self.volume(controller, controller.media_info.volume) + self.volume(controller, get_volume(controller)) return True def media_state_wait(self, controller, media_state): @@ -275,7 +273,7 @@ class VlcPlayer(MediaPlayer): threading.Thread(target=controller.vlc_media_player.play).start() if not self.media_state_wait(controller, VlCState.Playing): return False - self.volume(controller, controller.media_info.volume) + self.volume(controller, get_volume(controller)) self.set_state(MediaState.Playing, controller) return True diff --git a/tests/openlp_core/ui/media/test_mediacontroller.py b/tests/openlp_core/ui/media/test_mediacontroller.py index 81216d972..b5de7b257 100644 --- a/tests/openlp_core/ui/media/test_mediacontroller.py +++ b/tests/openlp_core/ui/media/test_mediacontroller.py @@ -22,14 +22,18 @@ Package to test the openlp.core.ui.media package. """ from pathlib import Path + +from unittest import skipUnless from unittest.mock import MagicMock, patch import pytest +from openlp.core.state import State +from openlp.core.common.platform import is_linux, is_macosx from openlp.core.common.registry import Registry from openlp.core.ui import DisplayControllerType, HideMode from openlp.core.ui.media.mediacontroller import MediaController -from openlp.core.ui.media import ItemMediaInfo, MediaState +from openlp.core.ui.media import ItemMediaInfo, MediaState, MediaType from tests.utils.constants import RESOURCE_PATH @@ -46,6 +50,216 @@ def media_env(registry): yield media_controller +@patch('openlp.core.ui.media.mediacontroller.register_views') +def test_setup(mocked_register_views, media_env): + """ + Test that the setup method is called correctly + """ + # GIVEN: A media controller, and function list + expected_functions_list = ['bootstrap_initialise', 'bootstrap_post_set_up', 'bootstrap_completion', + 'playbackPlay', 'playbackPause', 'playbackStop', 'playbackLoop', 'seek_slider', + 'volume_slider', 'media_hide', 'media_blank', 'media_unblank', 'songs_hide', + 'songs_blank', 'songs_unblank'] + # WHEN: Setup is called + media_env.setup() + # THEN: the functions should be defined along with the api blueprint + assert list(Registry().functions_list.keys()) == expected_functions_list, \ + f'The function list should have been {(Registry().functions_list.keys())}' + mocked_register_views.called_once(), 'The media blueprint has not been registered' + + +def test_initialise_good(media_env, state_media): + """ + Test that the bootstrap initialise method is called correctly + """ + # GIVEN: a mocked setup + with patch.object(media_env.media_controller, u'setup') as mocked_setup: + # THEN: The underlying method is called + media_env.media_controller.bootstrap_initialise() + # THEN: The following should have happened + mocked_setup.called_once(), 'The setup function has been called' + + +def test_initialise_missing_vlc(media_env, state_media): + """ + Test that the bootstrap initialise method is called correctly with no VLC + """ + # GIVEN: a mocked setup and no VLC + with patch.object(media_env.media_controller, u'setup') as mocked_setup, \ + patch('openlp.core.ui.media.mediacontroller.get_vlc', return_value=False): + # THEN: The underlying method is called + media_env.media_controller.bootstrap_initialise() + # THEN: The following should have happened + mocked_setup.called_once(), 'The setup function has been called' + text = State().get_text() + if not is_macosx(): + assert text.find("python3-vlc") > 0, "VLC should not be missing" + + +@patch('openlp.core.ui.media.mediacontroller.pymediainfo_available', False) +def test_initialise_missing_pymedia(media_env, state_media): + """ + Test that the bootstrap initialise method is called correctly with no pymediainfo + """ + # GIVEN: a mocked setup and no pymedia + with patch.object(media_env.media_controller, u'setup') as mocked_setup: + # THEN: The underlying method is called + media_env.media_controller.bootstrap_initialise() + # THEN: The following should have happened + mocked_setup.called_once(), 'The setup function has been called' + text = State().get_text() + if not is_macosx(): + assert text.find("python3-pymediainfo") > 0, "PyMedia should not be missing" + + +@skipUnless(is_linux(), "Linux only") +def test_initialise_missing_pymedia_fedora(media_env, state_media): + """ + Test that the bootstrap initialise method is called correctly with no VLC + """ + # GIVEN: a mocked setup and no VLC + with patch.object(media_env.media_controller, u'setup') as mocked_setup, \ + patch('openlp.core.ui.media.mediacontroller.get_vlc', return_value=False), \ + patch('openlp.core.ui.media.mediacontroller.is_linux', return_value=True): + # WHEN: The underlying method is called + media_env.media_controller.bootstrap_initialise() + # THEN: The following should have happened + mocked_setup.called_once(), 'The setup function has been called' + text = State().get_text() + assert text.find("python3-pymediainfo") == -1, "PyMedia should be missing" + assert text.find("python3-vlc") > 0, "VLC should not be missing" + assert text.find("rpmfusion") > 0, "RPMFusion should provide the modules" + + +@skipUnless(is_linux(), "Linux only") +def test_initialise_missing_pymedia_not_fedora(media_env, state_media): + """ + Test that the bootstrap initialise method is called correctly with no VLC + """ + # GIVEN: a mocked setup and no VLC + with patch.object(media_env.media_controller, u'setup') as mocked_setup, \ + patch('openlp.core.ui.media.mediacontroller.get_vlc', return_value=False), \ + patch('openlp.core.ui.media.mediacontroller.is_linux', return_value=False): + # WHEN: The underlying method is called + media_env.media_controller.bootstrap_initialise() + # THEN: The following should have happened + mocked_setup.called_once(), 'The setup function has been called' + text = State().get_text() + assert text.find("python3-pymediainfo") == -1, "PyMedia should be missing" + assert text.find("python3-vlc") > 0, "VLC should not be missing" + assert text.find("rpmfusion") == -1, "RPMFusion should not provide the modules" + + +def test_initialise_missing_pymedia_mac_os(media_env, state_media): + """ + Test that the bootstrap initialise method is called correctly with no VLC + """ + # GIVEN: a mocked setup and no VLC + with patch.object(media_env.media_controller, u'setup') as mocked_setup, \ + patch('openlp.core.ui.media.mediacontroller.get_vlc', return_value=False), \ + patch('openlp.core.ui.media.mediacontroller.is_macosx', return_value=True): + # WHEN: The underlying method is called + media_env.media_controller.bootstrap_initialise() + # THEN: The following should have happened + mocked_setup.called_once(), 'The setup function has been called' + text = State().get_text() + assert text.find("python3-pymediainfo") == -1, "PyMedia should be missing" + assert text.find("python3-vlc") == -1, "PyMedia should be missing" + assert text.find("videolan") > 0, "VideoLAN should provide the modules" + + +def test_post_set_up_good(media_env, state_media): + """ + Test the Bootstrap post set up assuming all functions are good + """ + # GIVEN: A working environment + media_env.vlc_live_media_stop = MagicMock() + media_env.vlc_preview_media_stop = MagicMock() + media_env.vlc_live_media_tick = MagicMock() + media_env.vlc_preview_media_tick = MagicMock() + State().add_service("mediacontroller", 0) + State().update_pre_conditions("mediacontroller", True) + # WHEN: I call the function + with patch.object(media_env.media_controller, u'setup_display') as mocked_display: + media_env.bootstrap_post_set_up() + # THEN: the environment is set up correctly + assert mocked_display.call_count == 2, "Should have been called twice" + text = State().get_text() + assert text.find("No Displays") == -1, "No Displays have been disable" + assert mocked_display.has_calls(None, False) # Live Controller + assert mocked_display.has_calls(None, True) # Preview Controller + + +def test_media_state_live(media_env, state_media): + """ + Test the Bootstrap post set up assuming all functions are good + """ + # GIVEN: A working environment + media_env.vlc_live_media_stop = MagicMock() + media_env.vlc_preview_media_stop = MagicMock() + media_env.vlc_preview_media_tick = MagicMock() + mocked_live_controller = MagicMock() + mocked_live_controller.is_live = True + mocked_live_controller.media_info.media_type = MediaType.Audio + Registry().register('live_controller', mocked_live_controller) + media_env.media_controller.vlc_player = MagicMock() + media_env.media_controller._display_controllers = MagicMock(return_value=mocked_live_controller) + # WHEN: I call the function + with patch.object(media_env.media_controller, u'setup_display') as mocked_display: + media_env.bootstrap_post_set_up() + # THEN: the environment is set up correctly + text = State().get_text() + assert text.find("No Displays") == -1, "No Displays have been disable" + assert mocked_display.has_calls(None, False) # Live Controller + assert mocked_display.has_calls(None, True) # Preview Controller + + +def test_post_set_up_no_controller(media_env, state_media): + """ + Test the Bootstrap post set up assuming all functions are good + """ + # GIVEN: A working environment + media_env.vlc_live_media_stop = MagicMock() + media_env.vlc_preview_media_stop = MagicMock() + media_env.vlc_live_media_tick = MagicMock() + media_env.vlc_preview_media_tick = MagicMock() + State().add_service("mediacontroller", 0) + State().update_pre_conditions("mediacontroller", False) + # WHEN: I call the function + with patch.object(media_env.media_controller, u'setup_display') as mocked_display: + media_env.bootstrap_post_set_up() + # THEN: the environment is set up correctly + assert mocked_display.call_count == 0, "Should have not have been called twice" + text = State().get_text() + assert text.find("No Displays") == -1, "No Displays have been disable" + + +def test_post_set_up_controller_exception(media_env, state_media): + """ + Test the Bootstrap post set up assuming all functions are good + """ + # GIVEN: A working environment + media_env.vlc_live_media_stop = MagicMock() + media_env.vlc_preview_media_stop = MagicMock() + media_env.vlc_live_media_tick = MagicMock() + media_env.vlc_preview_media_tick = MagicMock() + State().add_service("mediacontroller", 0) + State().update_pre_conditions("mediacontroller", True) + State().add_service("media_live", 0) + State().update_pre_conditions("media_live", True) + # WHEN: I call the function + with patch.object(media_env.media_controller, u'setup_display') as mocked_display: + mocked_display.side_effect = AttributeError() + try: + media_env.bootstrap_post_set_up() + except AttributeError: + pass + # THEN: the environment is set up correctly + text = State().get_text() + assert text.find("Displays") > 0, "Displays have been disable" + assert mocked_display.call_count == 2, "Should have been called twice" + + def test_resize(media_env): """ Test that the resize method is called correctly @@ -86,7 +300,6 @@ def test_load_video(media_env, settings): # The video should have autoplayed # The controls should have been made visible media_env.media_controller.media_reset.assert_called_once_with(mocked_slide_controller) - assert mocked_slide_controller.media_info.volume == 1 media_env.media_controller.media_play.assert_called_once_with(mocked_slide_controller, False) media_env.media_controller.set_controls_visible.assert_called_once_with(mocked_slide_controller, True) diff --git a/tests/openlp_core/ui/media/test_vlcplayer.py b/tests/openlp_core/ui/media/test_vlcplayer.py index bd3b4ef6d..57a64b7f1 100644 --- a/tests/openlp_core/ui/media/test_vlcplayer.py +++ b/tests/openlp_core/ui/media/test_vlcplayer.py @@ -283,7 +283,7 @@ def test_check_not_available(mocked_get_vlc): @patch('openlp.core.ui.media.vlcplayer.get_vlc') @patch('openlp.core.ui.media.vlcplayer.os.path.normcase') -def test_load(mocked_normcase, mocked_get_vlc): +def test_load(mocked_normcase, mocked_get_vlc, settings): """ Test loading a video into VLC """ @@ -294,7 +294,6 @@ def test_load(mocked_normcase, mocked_get_vlc): mocked_get_vlc.return_value = mocked_vlc mocked_display = MagicMock() 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() @@ -305,8 +304,7 @@ def test_load(mocked_normcase, mocked_get_vlc): 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_controller, mocked_display, media_path) + result = vlc_player.load(mocked_controller, mocked_display, media_path) # THEN: The video should be loaded mocked_normcase.assert_called_with(media_path) @@ -314,14 +312,13 @@ def test_load(mocked_normcase, mocked_get_vlc): assert mocked_vlc_media == mocked_controller.vlc_media mocked_controller.vlc_media_player.set_media.assert_called_with(mocked_vlc_media) mocked_vlc_media.parse.assert_called_with() - mocked_volume.assert_called_with(mocked_controller, 100) assert result is True @patch('openlp.core.ui.media.vlcplayer.is_win') @patch('openlp.core.ui.media.vlcplayer.get_vlc') @patch('openlp.core.ui.media.vlcplayer.os.path.normcase') -def test_load_audio_cd(mocked_normcase, mocked_get_vlc, mocked_is_win): +def test_load_audio_cd(mocked_normcase, mocked_get_vlc, mocked_is_win, settings): """ Test loading an audio CD into VLC """ @@ -333,7 +330,6 @@ def test_load_audio_cd(mocked_normcase, mocked_get_vlc, mocked_is_win): mocked_get_vlc.return_value = mocked_vlc mocked_display = MagicMock() mocked_controller = MagicMock() - mocked_controller.media_info.volume = 100 mocked_controller.media_info.media_type = MediaType.CD mocked_controller.media_info.title_track = 1 mocked_vlc_media = MagicMock() @@ -351,8 +347,7 @@ def test_load_audio_cd(mocked_normcase, mocked_get_vlc, mocked_is_win): vlc_player = VlcPlayer(None) # WHEN: An audio CD is loaded into VLC - with patch.object(vlc_player, 'volume') as mocked_volume, \ - patch.object(vlc_player, 'media_state_wait') as mocked_media_state_wait: + with patch.object(vlc_player, 'media_state_wait') as mocked_media_state_wait: result = vlc_player.load(mocked_controller, mocked_display, media_path) # THEN: The video should be loaded @@ -361,7 +356,6 @@ def test_load_audio_cd(mocked_normcase, mocked_get_vlc, mocked_is_win): assert mocked_vlc_media == mocked_controller.vlc_media mocked_controller.vlc_media_player.set_media.assert_called_with(mocked_vlc_media) mocked_vlc_media.parse.assert_called_with() - mocked_volume.assert_called_with(mocked_controller, 100) mocked_media_state_wait.assert_called_with(mocked_controller, ANY) mocked_controller.seek_slider.setMinimum.assert_called_with(20000) mocked_controller.seek_slider.setMaximum.assert_called_with(30000) @@ -371,7 +365,7 @@ def test_load_audio_cd(mocked_normcase, mocked_get_vlc, mocked_is_win): @patch('openlp.core.ui.media.vlcplayer.is_win') @patch('openlp.core.ui.media.vlcplayer.get_vlc') @patch('openlp.core.ui.media.vlcplayer.os.path.normcase') -def test_load_audio_cd_on_windows(mocked_normcase, mocked_get_vlc, mocked_is_win): +def test_load_audio_cd_on_windows(mocked_normcase, mocked_get_vlc, mocked_is_win, settings): """ Test loading an audio CD into VLC on Windows """ @@ -383,7 +377,6 @@ def test_load_audio_cd_on_windows(mocked_normcase, mocked_get_vlc, mocked_is_win mocked_get_vlc.return_value = mocked_vlc mocked_display = MagicMock() mocked_controller = MagicMock() - mocked_controller.media_info.volume = 100 mocked_controller.media_info.media_type = MediaType.CD mocked_controller.media_info.file_info.absoluteFilePath.return_value = media_path mocked_controller.media_info.title_track = 1 @@ -400,8 +393,7 @@ def test_load_audio_cd_on_windows(mocked_normcase, mocked_get_vlc, mocked_is_win vlc_player = VlcPlayer(None) # WHEN: An audio CD is loaded into VLC - with patch.object(vlc_player, 'volume') as mocked_volume, \ - patch.object(vlc_player, 'media_state_wait') as mocked_media_state_wait: + with patch.object(vlc_player, 'media_state_wait') as mocked_media_state_wait: result = vlc_player.load(mocked_controller, mocked_display, media_path) # THEN: The video should be loaded @@ -410,7 +402,6 @@ def test_load_audio_cd_on_windows(mocked_normcase, mocked_get_vlc, mocked_is_win assert mocked_vlc_media == mocked_controller.vlc_media mocked_controller.vlc_media_player.set_media.assert_called_with(mocked_vlc_media) mocked_vlc_media.parse.assert_called_with() - mocked_volume.assert_called_with(mocked_controller, 100) mocked_media_state_wait.assert_called_with(mocked_controller, ANY) assert result is True @@ -449,7 +440,7 @@ def test_load_audio_cd_no_tracks(mocked_normcase, mocked_get_vlc, mocked_is_win) vlc_player = VlcPlayer(None) # WHEN: An audio CD is loaded into VLC - with patch.object(vlc_player, 'volume'), patch.object(vlc_player, 'media_state_wait'): + with patch.object(vlc_player, 'media_state_wait'): result = vlc_player.load(mocked_controller, mocked_display, media_path) # THEN: The video should be loaded @@ -465,7 +456,7 @@ def test_load_audio_cd_no_tracks(mocked_normcase, mocked_get_vlc, mocked_is_win) @patch('openlp.core.ui.media.vlcplayer.is_win') @patch('openlp.core.ui.media.vlcplayer.get_vlc') @patch('openlp.core.ui.media.vlcplayer.os.path.normcase') -def test_load_dvd(mocked_normcase, mocked_get_vlc, mocked_is_win): +def test_load_dvd(mocked_normcase, mocked_get_vlc, mocked_is_win, settings): """ Test loading a DVD into VLC """ @@ -477,14 +468,12 @@ def test_load_dvd(mocked_normcase, mocked_get_vlc, mocked_is_win): mocked_get_vlc.return_value = mocked_vlc mocked_display = MagicMock() mocked_controller = MagicMock() - mocked_controller.media_info.volume = 100 mocked_controller.media_info.media_type = MediaType.DVD mocked_controller.media_info.title_track = '2' mocked_controller.media_info.audio_track = 2 mocked_controller.media_info.subtitle_track = 4 mocked_vlc_media = MagicMock() mocked_media = MagicMock() - mocked_controller.media_info.volume = 100 mocked_controller.media_info.start_time = 20000 mocked_controller.media_info.end_time = 30000 mocked_controller.media_info.length = 10000 @@ -493,8 +482,7 @@ def test_load_dvd(mocked_normcase, mocked_get_vlc, mocked_is_win): vlc_player = VlcPlayer(None) # WHEN: A DVD clip is loaded into VLC - with patch.object(vlc_player, 'volume') as mocked_volume, \ - patch.object(vlc_player, 'media_state_wait') as mocked_media_state_wait: + with patch.object(vlc_player, 'media_state_wait') as mocked_media_state_wait: result = vlc_player.load(mocked_controller, mocked_display, media_path) # THEN: The video should be loaded @@ -505,7 +493,6 @@ def test_load_dvd(mocked_normcase, mocked_get_vlc, mocked_is_win): mocked_controller.vlc_media_player.audio_set_track.assert_called_with(2) mocked_controller.vlc_media_player.video_set_spu.assert_called_with(4) mocked_vlc_media.parse.assert_called_with() - mocked_volume.assert_called_with(mocked_controller, 100) mocked_media_state_wait.assert_called_with(mocked_controller, ANY) mocked_controller.seek_slider.setMinimum.assert_called_with(20000) mocked_controller.seek_slider.setMaximum.assert_called_with(30000) @@ -606,7 +593,7 @@ def test_resize(): @patch('openlp.core.ui.media.vlcplayer.threading') @patch('openlp.core.ui.media.vlcplayer.get_vlc') -def test_play(mocked_get_vlc, mocked_threading): +def test_play(mocked_get_vlc, mocked_threading, settings): """ Test the play() method """ @@ -618,21 +605,17 @@ def test_play(mocked_get_vlc, mocked_threading): mocked_display = MagicMock() mocked_controller = MagicMock() mocked_media = MagicMock() - mocked_controller.media_info.volume = 100 mocked_controller.vlc_media_player.get_media.return_value = mocked_media vlc_player = VlcPlayer(None) vlc_player.set_state(MediaState.Paused, mocked_controller) # 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: + with patch.object(vlc_player, 'media_state_wait') as mocked_media_state_wait: mocked_media_state_wait.return_value = True result = vlc_player.play(mocked_controller, 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_controller, 100) - assert MediaState.Playing == vlc_player.get_live_state() assert result is True, 'The value returned from play() should be True'