def test_media_state_wait_error(self, mocked_get_vlc):
"""
Check that getting an error when waiting for a state change returns False
"""
# GIVEN: A mocked out get_vlc method
mocked_vlc = MagicMock()
mocked_vlc.State.Error = 1
mocked_get_vlc.return_value = mocked_vlc
mocked_display = MagicMock()
mocked_display.vlc_media.get_state.return_value = 1
Registry.create()
mocked_application = MagicMock()
Registry().register('application', mocked_application)
vlc_player = VlcPlayer(None)
# WHEN: media_state_wait() is called
result = vlc_player.media_state_wait(mocked_display, 2)
# THEN: The results should be True
assert result is False
def media_state_wait_test(self, mocked_get_vlc):
"""
Check that waiting for a state change works
"""
# GIVEN: A mocked out get_vlc method
mocked_vlc = MagicMock()
mocked_vlc.State.Error = 1
mocked_get_vlc.return_value = mocked_vlc
mocked_display = MagicMock()
mocked_display.vlc_media.get_state.return_value = 2
Registry.create()
mocked_application = MagicMock()
Registry().register('application', mocked_application)
vlc_player = VlcPlayer(None)
# WHEN: media_state_wait() is called
result = vlc_player.media_state_wait(mocked_display, 2)
# THEN: The results should be True
self.assertTrue(result)
def test_load_audio_cd(mocked_normcase, mocked_get_vlc, mocked_is_win):
"""
Test loading an audio CD into VLC
"""
# GIVEN: A mocked out get_vlc() method
mocked_is_win.return_value = False
media_path = '/dev/sr0'
mocked_normcase.side_effect = lambda x: x
mocked_vlc = MagicMock()
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()
mocked_media = MagicMock()
mocked_media.get_duration.return_value = 10000
mocked_controller.vlc_instance.media_new_location.return_value = mocked_vlc_media
mocked_controller.vlc_media_player.get_media.return_value = mocked_media
mocked_subitems = MagicMock()
mocked_subitems.count.return_value = 1
mocked_subitems.item_at_index.return_value = mocked_vlc_media
mocked_vlc_media.subitems.return_value = mocked_subitems
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'):
result = vlc_player.load(mocked_controller, mocked_display, media_path)
# THEN: The video should be loaded
mocked_normcase.assert_called_with(media_path)
mocked_controller.vlc_instance.media_new_location.assert_called_with(
'cdda://' + media_path)
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
def bootstrap_initialise(self):
"""
Check to see if we have any media Player's available.
"""
self.setup()
self.vlc_player = VlcPlayer(self)
State().add_service('mediacontroller', 0)
State().add_service('media_live', 0)
has_vlc = get_vlc()
if has_vlc and pymediainfo_available:
State().update_pre_conditions('mediacontroller', True)
State().update_pre_conditions('media_live', True)
else:
if hasattr(self.main_window,
'splash') and self.main_window.splash.isVisible():
self.main_window.splash.hide()
generic_message = translate(
'OpenLP.MediaController',
'OpenLP requires the following libraries in order to show videos and other '
'media, but they are not installed. Please install these libraries to enable '
'media playback in OpenLP.')
fedora_rpmfusion = translate(
'OpenLP.MediaController',
'To install these libraries, you will need to enable the RPMFusion '
'repository: https://rpmfusion.org/')
if is_macosx():
message = translate(
'OpenLP.MediaController',
'macOS is missing VLC. Please download and install from the VLC web site: '
'https://www.videolan.org/vlc/')
else:
packages = []
if not has_vlc:
packages.append('python3-vlc')
if not pymediainfo_available:
packages.append('python3-pymediainfo')
message = generic_message + '\n\n' + ', '.join(packages)
if not has_vlc and is_linux(distro='fedora'):
message += '\n\n' + fedora_rpmfusion
State().missing_text('media_live', message)
return True
def play_dvd_test(self, mocked_get_vlc, mocked_threading):
"""
Test the play() method with a DVD
"""
# 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.end_time = 50
mocked_controller.media_info.media_type = MediaType.DVD
mocked_controller.media_info.volume = 100
mocked_controller.media_info.title_track = 1
mocked_controller.media_info.audio_track = 1
mocked_controller.media_info.subtitle_track = 1
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 = 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_display.vlc_media_player.set_title.assert_called_with(1)
mocked_display.vlc_media_player.play.assert_called_with()
mocked_display.vlc_media_player.audio_set_track.assert_called_with(1)
mocked_display.vlc_media_player.video_set_spu.assert_called_with(1)
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_media_state_wait_times_out(self, mocked_get_vlc):
"""
Check that waiting for a state returns False when it times out after 60 seconds
"""
# GIVEN: A mocked out get_vlc method
timeout = MockDateTime.return_values[0] + timedelta(seconds=61)
MockDateTime.return_values.append(timeout)
mocked_vlc = MagicMock()
mocked_vlc.State.Error = 1
mocked_get_vlc.return_value = mocked_vlc
mocked_display = MagicMock()
mocked_display.vlc_media.get_state.return_value = 2
Registry.create()
mocked_application = MagicMock()
Registry().register('application', mocked_application)
vlc_player = VlcPlayer(None)
# WHEN: media_state_wait() is called
result = vlc_player.media_state_wait(mocked_display, 3)
# THEN: The results should be True
self.assertFalse(result)
def test_play_dvd(mocked_get_vlc, mocked_threading):
"""
Test the play() method with a DVD
"""
# 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_output_display = MagicMock()
mocked_controller.media_info = ItemMediaInfo()
mocked_controller.media_info.start_time = 0
mocked_controller.media_info.end_time = 50
mocked_controller.media_info.media_type = MediaType.DVD
mocked_controller.media_info.volume = 100
mocked_controller.media_info.title_track = 1
mocked_controller.media_info.audio_track = 1
mocked_controller.media_info.subtitle_track = 1
vlc_player = VlcPlayer(None)
vlc_player.set_state(MediaState.Paused, mocked_output_display)
# WHEN: play() is called
with patch.object(vlc_player, 'media_state_wait', return_value=True), \
patch.object(vlc_player, 'volume') as mocked_volume, \
patch.object(vlc_player, 'get_live_state', return_value=MediaState.Loaded):
result = vlc_player.play(mocked_controller, mocked_output_display)
# THEN: A bunch of things should happen to play the media
mocked_thread.start.assert_called_with()
mocked_controller.vlc_media_player.set_title.assert_called_with(1)
mocked_controller.vlc_media_player.play.assert_called_with()
mocked_controller.vlc_media_player.audio_set_track.assert_called_with(1)
mocked_controller.vlc_media_player.video_set_spu.assert_called_with(1)
mocked_volume.assert_called_with(mocked_controller, 100)
assert MediaState.Playing == vlc_player.get_live_state()
mocked_controller.vlc_widget.raise_.assert_called_with()
assert result is True, 'The value returned from play() should be True'
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 test_pause_fail(self, mocked_get_vlc):
"""
Test the pause method when the player fails to pause the media
"""
# GIVEN: A mocked out get_vlc method
mocked_vlc = MagicMock()
mocked_vlc.State.Playing = 1
mocked_vlc.State.Paused = 2
mocked_get_vlc.return_value = mocked_vlc
mocked_display = MagicMock()
mocked_display.vlc_media.get_state.return_value = 1
vlc_player = VlcPlayer(None)
# WHEN: The media is paused
with patch.object(vlc_player,
'media_state_wait') as mocked_media_state_wait:
mocked_media_state_wait.return_value = False
vlc_player.pause(mocked_display)
# THEN: The pause method should exit early
mocked_display.vlc_media.get_state.assert_called_with()
mocked_display.vlc_media_player.pause.assert_called_with()
mocked_media_state_wait.assert_called_with(mocked_display, 2)
self.assertNotEqual(MediaState.Paused, vlc_player.state)
def test_pause(mocked_get_vlc):
"""
Test that the pause method works correctly
"""
# GIVEN: A mocked out get_vlc method
mocked_vlc = MagicMock()
mocked_vlc.State.Playing = 1
mocked_vlc.State.Paused = 2
mocked_get_vlc.return_value = mocked_vlc
mocked_display = MagicMock()
mocked_display.vlc_media.get_state.return_value = 1
vlc_player = VlcPlayer(None)
# WHEN: The media is paused
with patch.object(vlc_player,
'media_state_wait') as mocked_media_state_wait:
mocked_media_state_wait.return_value = True
vlc_player.pause(mocked_display)
# THEN: The pause method should exit early
mocked_display.vlc_media.get_state.assert_called_with()
mocked_display.vlc_media_player.pause.assert_called_with()
mocked_media_state_wait.assert_called_with(mocked_display, 2)
assert MediaState.Paused == vlc_player.get_live_state()
def test_play_media_wait_state_not_playing(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_output_display = MagicMock()
vlc_player = VlcPlayer(None)
vlc_player.set_state(MediaState.Paused, mocked_output_display)
# WHEN: play() is called
with patch.object(vlc_player, 'media_state_wait') as mocked_media_state_wait, \
patch.object(vlc_player, 'volume'):
mocked_media_state_wait.return_value = False
result = vlc_player.play(mocked_controller, mocked_output_display)
# THEN: A thread should be started, but the method should return False
mocked_thread.start.assert_called_with()
assert result is False
