def test_check_file_type_no_players(self):
"""
Test that we don't try to play media when no players available
"""
# GIVEN: A mocked UiStrings, get_used_players, controller, display and service_item
with patch('openlp.core.ui.media.mediacontroller.MediaController._get_used_players') as \
mocked_get_used_players,\
patch('openlp.core.ui.media.mediacontroller.UiStrings') as mocked_uistrings:
mocked_get_used_players.return_value = ([])
mocked_ret_uistrings = MagicMock()
mocked_ret_uistrings.Automatic = 1
mocked_uistrings.return_value = mocked_ret_uistrings
media_controller = MediaController()
mocked_controller = MagicMock()
mocked_display = MagicMock()
mocked_service_item = MagicMock()
mocked_service_item.processor = 1
# WHEN: calling _check_file_type when no players exists
ret = media_controller._check_file_type(mocked_controller,
mocked_display,
mocked_service_item)
# THEN: it should return False
self.assertFalse(
ret,
'_check_file_type should return False when no mediaplayers are available.'
)
def test_check_file_type_automatic_processor(self, mocked_uistrings, mocked_get_used_players):
"""
Test that we can play media when players are available and we have a automatic processor from the service item
"""
# GIVEN: A mocked UiStrings, get_media_players, controller, display and service_item
mocked_get_used_players.return_value = (['vlc', 'webkit'])
mocked_ret_uistrings = MagicMock()
mocked_ret_uistrings.Automatic = 1
mocked_uistrings.return_value = mocked_ret_uistrings
media_controller = MediaController()
mocked_vlc = MagicMock()
mocked_vlc.video_extensions_list = ['*.mp4']
media_controller.media_players = {'vlc': mocked_vlc, 'webkit': MagicMock()}
mocked_controller = MagicMock()
mocked_suffix = MagicMock()
mocked_suffix.return_value = 'mp4'
mocked_controller.media_info.file_info.suffix = mocked_suffix
mocked_display = MagicMock()
mocked_service_item = MagicMock()
mocked_service_item.processor = 1
# WHEN: calling _check_file_type when the processor for the service item is None
ret = media_controller._check_file_type(mocked_controller, mocked_display, mocked_service_item)
# THEN: it should return True
self.assertTrue(ret, '_check_file_type should return True when mediaplayers are available and '
'the service item has an automatic processor.')
def test_check_file_type_automatic_processor(self, mocked_uistrings,
mocked_get_used_players):
"""
Test that we can play media when players are available and we have a automatic processor from the service item
"""
# GIVEN: A mocked UiStrings, get_media_players, controller, display and service_item
mocked_get_used_players.return_value = (['vlc', 'webkit'])
mocked_ret_uistrings = MagicMock()
mocked_ret_uistrings.Automatic = 1
mocked_uistrings.return_value = mocked_ret_uistrings
media_controller = MediaController()
mocked_vlc = MagicMock()
mocked_vlc.video_extensions_list = ['*.mp4']
media_controller.media_players = {
'vlc': mocked_vlc,
'webkit': MagicMock()
}
mocked_controller = MagicMock()
mocked_suffix = MagicMock()
mocked_suffix.return_value = 'mp4'
mocked_controller.media_info.file_info.suffix = mocked_suffix
mocked_display = MagicMock()
mocked_service_item = MagicMock()
mocked_service_item.processor = 1
# WHEN: calling _check_file_type when the processor for the service item is None
ret = media_controller._check_file_type(mocked_controller,
mocked_display,
mocked_service_item)
# THEN: it should return True
self.assertTrue(
ret,
'_check_file_type should return True when mediaplayers are available and '
'the service item has an automatic processor.')
def test_check_file_type_processor_different_from_available(
self, mocked_uistrings, mocked_get_used_players):
"""
Test that we can play media when players available are different from the processor from the service item
"""
# GIVEN: A mocked UiStrings, get_media_players, controller, display and service_item
mocked_get_used_players.return_value = (['system'])
mocked_ret_uistrings = MagicMock()
mocked_ret_uistrings.Automatic = 'automatic'
mocked_uistrings.return_value = mocked_ret_uistrings
media_controller = MediaController()
mocked_phonon = MagicMock()
mocked_phonon.video_extensions_list = ['*.mp4']
media_controller.media_players = {'system': mocked_phonon}
mocked_controller = MagicMock()
mocked_suffix = MagicMock()
mocked_suffix.return_value = 'mp4'
mocked_controller.media_info.file_info.suffix = mocked_suffix
mocked_display = MagicMock()
mocked_service_item = MagicMock()
mocked_service_item.processor = 'vlc'
# WHEN: calling _check_file_type when the processor for the service item is None
ret = media_controller._check_file_type(mocked_controller,
mocked_display,
mocked_service_item)
# THEN: it should return True
self.assertTrue(
ret,
'_check_file_type should return True when the players available are different'
'from the processor from the service item.')
def test_check_file_type_processor_different_from_available(self, mocked_uistrings, mocked_get_used_players):
"""
Test that we can play media when players available are different from the processor from the service item
"""
# GIVEN: A mocked UiStrings, get_media_players, controller, display and service_item
mocked_get_used_players.return_value = (['system'])
mocked_ret_uistrings = MagicMock()
mocked_ret_uistrings.Automatic = 'automatic'
mocked_uistrings.return_value = mocked_ret_uistrings
media_controller = MediaController()
mocked_phonon = MagicMock()
mocked_phonon.video_extensions_list = ['*.mp4']
media_controller.media_players = {'system': mocked_phonon}
mocked_controller = MagicMock()
mocked_suffix = MagicMock()
mocked_suffix.return_value = 'mp4'
mocked_controller.media_info.file_info.suffix = mocked_suffix
mocked_display = MagicMock()
mocked_service_item = MagicMock()
mocked_service_item.processor = 'vlc'
# WHEN: calling _check_file_type when the processor for the service item is None
ret = media_controller._check_file_type(mocked_controller, mocked_display, mocked_service_item)
# THEN: it should return True
self.assertTrue(ret, '_check_file_type should return True when the players available are different'
'from the processor from the service item.')
def test_check_file_type_no_processor(self, mocked_uistrings,
mocked_get_used_players):
"""
Test that we don't try to play media when the processor for the service item is None
"""
# GIVEN: A mocked UiStrings, get_media_players, controller, display and service_item
mocked_get_used_players.return_value = ([], '')
mocked_ret_uistrings = MagicMock()
mocked_ret_uistrings.Automatic = 1
mocked_uistrings.return_value = mocked_ret_uistrings
media_controller = MediaController()
mocked_controller = MagicMock()
mocked_display = MagicMock()
mocked_service_item = MagicMock()
mocked_service_item.processor = None
# WHEN: calling _check_file_type when the processor for the service item is None
ret = media_controller._check_file_type(mocked_controller,
mocked_display,
mocked_service_item)
# THEN: it should return False
self.assertFalse(
ret,
'_check_file_type should return False when the processor for service_item is None.'
)
def test_set_controls_visible(media_env):
"""
Test that "set_controls_visible" sets the media controls on the controller to be visible or not
"""
# GIVEN: A mocked controller
mocked_controller = MagicMock()
# WHEN: Set to visible
MediaController.set_controls_visible(mocked_controller, True)
# THEN: The media controls should have been set to visible
mocked_controller.mediabar.setVisible.assert_called_once_with(True)
def media_stop_msg_test(self):
"""
Test that the media controller responds to the request to stop a loaded video
"""
# GIVEN: A media controller and a message with two elements
media_controller = MediaController()
message = (1, 2)
# WHEN: media_play_msg() is called
with patch.object(media_controller, u'media_stop') as mocked_media_stop:
media_controller.media_stop_msg(message)
# THEN: The underlying method is called
mocked_media_stop.assert_called_with(1)
def test_resize(self):
"""
Test that the resize method is called correctly
"""
# GIVEN: A media controller, a player and a display
media_controller = MediaController()
mocked_player = MagicMock()
mocked_display = MagicMock()
# WHEN: resize() is called
media_controller.resize(mocked_display, mocked_player)
# THEN: The player's resize method should be called correctly
mocked_player.resize.assert_called_with(mocked_display)
def resize_test(self):
"""
Test that the resize method is called correctly
"""
# GIVEN: A media controller, a player and a display
media_controller = MediaController()
mocked_player = MagicMock()
mocked_display = MagicMock()
# WHEN: resize() is called
media_controller.resize(mocked_display, mocked_player)
# THEN: The player's resize method should be called correctly
mocked_player.resize.assert_called_with(mocked_display)
def media_seek_msg_test(self):
"""
Test that the media controller responds to the request to seek to a particular position
"""
# GIVEN: A media controller and a message with two elements
media_controller = MediaController()
message = (1, [800])
# WHEN: media_play_msg() is called
with patch.object(media_controller, u'media_seek') as mocked_media_seek:
media_controller.media_seek_msg(message)
# THEN: The underlying method is called
mocked_media_seek.assert_called_with(1, 800)
def media_volume_msg_test(self):
"""
Test that the media controller responds to the request to change the volume
"""
# GIVEN: A media controller and a message with two elements
media_controller = MediaController()
message = (1, [50])
# WHEN: media_play_msg() is called
with patch.object(media_controller, u'media_volume') as mocked_media_volume:
media_controller.media_volume_msg(message)
# THEN: The underlying method is called
mocked_media_volume.assert_called_with(1, 50)
def test_media_stop_msg(self):
"""
Test that the media controller responds to the request to stop a loaded video
"""
# GIVEN: A media controller and a message with two elements
media_controller = MediaController()
message = (1, 2)
# WHEN: media_play_msg() is called
with patch.object(media_controller,
u'media_stop') as mocked_media_stop:
media_controller.media_stop_msg(message)
# THEN: The underlying method is called
mocked_media_stop.assert_called_with(1)
def test_media_seek_msg(self):
"""
Test that the media controller responds to the request to seek to a particular position
"""
# GIVEN: A media controller and a message with two elements
media_controller = MediaController()
message = (1, [800])
# WHEN: media_play_msg() is called
with patch.object(media_controller,
u'media_seek') as mocked_media_seek:
media_controller.media_seek_msg(message)
# THEN: The underlying method is called
mocked_media_seek.assert_called_with(1, 800)
def test_media_volume_msg(self):
"""
Test that the media controller responds to the request to change the volume
"""
# GIVEN: A media controller and a message with two elements
media_controller = MediaController()
message = (1, [50])
# WHEN: media_play_msg() is called
with patch.object(media_controller,
u'media_volume') as mocked_media_volume:
media_controller.media_volume_msg(message)
# THEN: The underlying method is called
mocked_media_volume.assert_called_with(1, 50)
def generate_extensions_lists_test(self):
"""
Test that the extensions are create correctly
"""
# GIVEN: A MediaController and an active player with audio and video extensions
media_controller = MediaController()
media_player = MediaPlayer(None)
media_player.is_active = True
media_player.audio_extensions_list = ['*.mp3', '*.wav', '*.wma', '*.ogg']
media_player.video_extensions_list = ['*.mp4', '*.mov', '*.avi', '*.ogm']
media_controller.register_players(media_player)
# WHEN: calling _generate_extensions_lists
media_controller._generate_extensions_lists()
# THEN: extensions list should have been copied from the player to the mediacontroller
self.assertListEqual(media_player.video_extensions_list, media_controller.video_extensions_list,
'Video extensions should be the same')
self.assertListEqual(media_player.audio_extensions_list, media_controller.audio_extensions_list,
'Audio extensions should be the same')
def check_file_type_no_processor_test(self, mocked_uistrings, mocked_get_media_players):
"""
Test that we don't try to play media when the processor for the service item is None
"""
# GIVEN: A mocked UiStrings, get_media_players, controller, display and service_item
mocked_get_media_players.return_value = ([], '')
mocked_ret_uistrings = MagicMock()
mocked_ret_uistrings.Automatic = 1
mocked_uistrings.return_value = mocked_ret_uistrings
media_controller = MediaController()
mocked_controller = MagicMock()
mocked_display = MagicMock()
mocked_service_item = MagicMock()
mocked_service_item.processor = None
# WHEN: calling _check_file_type when the processor for the service item is None
ret = media_controller._check_file_type(mocked_controller, mocked_display, mocked_service_item)
# THEN: it should return False
self.assertFalse(ret, '_check_file_type should return False when the processor for service_item is None.')
def test_generate_extensions_lists(self):
"""
Test that the extensions are create correctly
"""
# GIVEN: A MediaController and an active player with audio and video extensions
media_controller = MediaController()
media_player = MediaPlayer(None)
media_player.is_active = True
media_player.audio_extensions_list = [
'*.mp3', '*.wav', '*.wma', '*.ogg'
]
media_player.video_extensions_list = [
'*.mp4', '*.mov', '*.avi', '*.ogm'
]
media_controller.register_players(media_player)
# WHEN: calling _generate_extensions_lists
media_controller._generate_extensions_lists()
# THEN: extensions list should have been copied from the player to the mediacontroller
self.assertListEqual(media_player.video_extensions_list,
media_controller.video_extensions_list,
'Video extensions should be the same')
self.assertListEqual(media_player.audio_extensions_list,
media_controller.audio_extensions_list,
'Audio extensions should be the same')
def check_file_type_no_players_test(self):
"""
Test that we don't try to play media when no players available
"""
# GIVEN: A mocked UiStrings, get_media_players, controller, display and service_item
with patch('openlp.core.ui.media.mediacontroller.get_media_players') as mocked_get_media_players,\
patch('openlp.core.ui.media.mediacontroller.UiStrings') as mocked_uistrings:
mocked_get_media_players.return_value = ([], '')
mocked_ret_uistrings = MagicMock()
mocked_ret_uistrings.Automatic = 1
mocked_uistrings.return_value = mocked_ret_uistrings
media_controller = MediaController()
mocked_controller = MagicMock()
mocked_display = MagicMock()
mocked_service_item = MagicMock()
mocked_service_item.processor = 1
# WHEN: calling _check_file_type when no players exists
ret = media_controller._check_file_type(mocked_controller, mocked_display, mocked_service_item)
# THEN: it should return False
self.assertFalse(ret, '_check_file_type should return False when no mediaplayers are available.')
def loader():
"""
God class to load all the components which are registered with the Registry
:return: None
"""
State().load_settings()
MediaController()
PluginManager()
# Set up the path with plugins
ImageManager()
Renderer()
# Create slide controllers
PreviewController()
LiveController()
def media_env(registry):
"""Local test setup"""
Registry().register('service_manager', MagicMock())
media_controller = MediaController()
yield media_controller
