mirror of https://gitlab.com/openlp/openlp.git
Merge branch 'vlc_cleanup2' into 'master'
Vlc cleanup2 See merge request openlp/openlp!539
This commit is contained in:
commit
3498de7642
|
|
@ -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': '',
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
||||
|
|
|
|||
|
|
@ -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'
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue