From 8838e671fca9c878e7914c415cb51c08c7cf039a Mon Sep 17 00:00:00 2001 From: Tim Bentley Date: Tue, 26 Nov 2019 17:49:41 +0000 Subject: [PATCH] Try to fix paths in coverage report generation - Add the local path to coverage config - Fix the paths before generating an HTML report --- openlp/core/app.py | 7 +- openlp/core/common/mixins.py | 10 + openlp/core/ui/media/mediacontroller.py | 2 - openlp/plugins/bibles/lib/mediaitem.py | 22 +- tests/conftest.py | 62 + tests/functional/openlp_core/test_app.py | 3 + .../openlp_core/ui/media/test_media.py | 189 +- .../openlp_core/ui/media/test_vlcplayer.py | 1748 +++++++++-------- .../openlp_plugins/bibles/test_mediaitem.py | 6 +- 9 files changed, 1020 insertions(+), 1029 deletions(-) create mode 100644 tests/conftest.py diff --git a/openlp/core/app.py b/openlp/core/app.py index 3b1ac2f4c..15d8cfc6c 100644 --- a/openlp/core/app.py +++ b/openlp/core/app.py @@ -400,6 +400,9 @@ def main(): Registry.create() Registry().register('application', application) Registry().set_flag('no_web_server', args.no_web_server) + # Upgrade settings. + settings = Settings() + Registry().register('settings', settings) application.setApplicationVersion(get_version()['version']) # Check if an instance of OpenLP is already running. Quit if there is a running instance and the user only wants one server = Server() @@ -414,8 +417,6 @@ def main(): if application.is_data_path_missing(): server.close_server() sys.exit() - # Upgrade settings. - settings = Settings() if settings.can_upgrade(): now = datetime.now() # Only back up if OpenLP has previously run. @@ -435,7 +436,7 @@ def main(): translate('OpenLP', 'Settings back up failed.\n\nContinuing to upgrade.')) settings.upgrade_settings() # First time checks in settings - if not Settings().value('core/has run wizard'): + if not settings.value('core/has run wizard'): if not FirstTimeLanguageForm().exec(): # if cancel then stop processing server.close_server() diff --git a/openlp/core/common/mixins.py b/openlp/core/common/mixins.py index 30a8f3642..3290fb750 100644 --- a/openlp/core/common/mixins.py +++ b/openlp/core/common/mixins.py @@ -125,6 +125,7 @@ class RegistryProperties(object): _settings_form = None _alerts_manager = None _projector_manager = None + _settings = None @property def application(self): @@ -246,3 +247,12 @@ class RegistryProperties(object): if not hasattr(self, '_projector_manager') or not self._projector_manager: self._projector_manager = Registry().get('projector_manager') return self._projector_manager + + @property + def settings(self): + """ + Adds the projector manager to the class dynamically + """ + if not hasattr(self, '_settings') or not self._settings: + self._settings = Registry().get('settings') + return self._settings diff --git a/openlp/core/ui/media/mediacontroller.py b/openlp/core/ui/media/mediacontroller.py index 7745f70c8..c91ce3954 100644 --- a/openlp/core/ui/media/mediacontroller.py +++ b/openlp/core/ui/media/mediacontroller.py @@ -37,7 +37,6 @@ from openlp.core.api.http import register_endpoint from openlp.core.common.i18n import translate from openlp.core.common.mixins import LogMixin, RegistryProperties from openlp.core.common.registry import Registry, RegistryBase -from openlp.core.common.settings import Settings from openlp.core.lib.serviceitem import ItemCapabilities from openlp.core.lib.ui import critical_error_message_box from openlp.core.ui import DisplayControllerType @@ -64,7 +63,6 @@ class MediaController(RegistryBase, LogMixin, RegistryProperties): self.live_timer.setInterval(TICK_TIME) self.preview_timer = QtCore.QTimer() self.preview_timer.setInterval(TICK_TIME) - self.settings = Settings() # Signals self.live_timer.timeout.connect(self.media_state_live) self.preview_timer.timeout.connect(self.media_state_preview) diff --git a/openlp/plugins/bibles/lib/mediaitem.py b/openlp/plugins/bibles/lib/mediaitem.py index 9701c3e4f..95b90e38f 100755 --- a/openlp/plugins/bibles/lib/mediaitem.py +++ b/openlp/plugins/bibles/lib/mediaitem.py @@ -131,7 +131,7 @@ class BibleMediaItem(MediaManagerItem): self.bibles_go_live.connect(self.go_live_remote) self.bibles_add_to_service.connect(self.add_to_service_remote) # Place to store the search results for both bibles. - self.settings = self.plugin.settings_tab + self.settings_tab = self.plugin.settings_tab self.quick_preview_allowed = True self.has_search = True self.search_results = [] @@ -557,8 +557,8 @@ class BibleMediaItem(MediaManagerItem): :return: None """ # TODO: Change layout_style to a property - self.settings.layout_style = index - self.settings.layout_style_combo_box.setCurrentIndex(index) + self.settings_tab.layout_style = index + self.settings_tab.layout_style_combo_box.setCurrentIndex(index) Settings().setValue('{section}/verse layout style'.format(section=self.settings_section), index) def on_version_combo_box_index_changed(self): @@ -945,12 +945,12 @@ class BibleMediaItem(MediaManagerItem): raw_slides.append(bible_text.rstrip()) bible_text = '' # If we are 'Verse Per Slide' then create a new slide. - elif self.settings.layout_style == LayoutStyle.VersePerSlide: + elif self.settings_tab.layout_style == LayoutStyle.VersePerSlide: bible_text = '{first_version}{data[text]}'.format(first_version=verse_text, data=data) raw_slides.append(bible_text.rstrip()) bible_text = '' # If we are 'Verse Per Line' then force a new line. - elif self.settings.layout_style == LayoutStyle.VersePerLine: + elif self.settings_tab.layout_style == LayoutStyle.VersePerLine: bible_text = '{bible} {verse}{data[text]}\n'.format(bible=bible_text, verse=verse_text, data=data) # We have to be 'Continuous'. else: @@ -966,7 +966,7 @@ class BibleMediaItem(MediaManagerItem): if bible_text: raw_slides.append(bible_text.lstrip()) # Service Item: Capabilities - if self.settings.layout_style == LayoutStyle.Continuous and not data['second_bible']: + if self.settings_tab.layout_style == LayoutStyle.Continuous and not data['second_bible']: # Split the line but do not replace line breaks in renderer. service_item.add_capability(ItemCapabilities.NoLineBreaks) service_item.add_capability(ItemCapabilities.CanPreview) @@ -976,8 +976,8 @@ class BibleMediaItem(MediaManagerItem): # Service Item: Title service_item.title = '{verse} {version}'.format(verse=verses.format_verses(), version=verses.format_versions()) # Service Item: Theme - if self.settings.bible_theme: - service_item.theme = self.settings.bible_theme + if self.settings_tab.bible_theme: + service_item.theme = self.settings_tab.bible_theme for slide in raw_slides: service_item.add_from_text(slide) return True @@ -994,10 +994,10 @@ class BibleMediaItem(MediaManagerItem): :param verse: The verse number (int). :return: An empty or formatted string """ - if not self.settings.is_verse_number_visible: + if not self.settings_tab.is_verse_number_visible: return '' verse_separator = get_reference_separators()['verse'] - if not self.settings.show_new_chapters or old_chapter != chapter: + if not self.settings_tab.show_new_chapters or old_chapter != chapter: verse_text = '{chapter}{sep}{verse}'.format(chapter=chapter, sep=verse_separator, verse=verse) else: verse_text = verse @@ -1006,7 +1006,7 @@ class BibleMediaItem(MediaManagerItem): DisplayStyle.Round: ('(', ')'), DisplayStyle.Curly: ('{', '}'), DisplayStyle.Square: ('[', ']') - }[self.settings.display_style] + }[self.settings_tab.display_style] return '{{su}}{bracket[0]}{verse_text}{bracket[1]}{{/su}} '.format(verse_text=verse_text, bracket=bracket) def search(self, string, show_error=True): diff --git a/tests/conftest.py b/tests/conftest.py new file mode 100644 index 000000000..9bbd2018f --- /dev/null +++ b/tests/conftest.py @@ -0,0 +1,62 @@ +# -*- coding: utf-8 -*- + +########################################################################## +# OpenLP - Open Source Lyrics Projection # +# ---------------------------------------------------------------------- # +# Copyright (c) 2008-2019 OpenLP Developers # +# ---------------------------------------------------------------------- # +# This program is free software: you can redistribute it and/or modify # +# it under the terms of the GNU General Public License as published by # +# the Free Software Foundation, either version 3 of the License, or # +# (at your option) any later version. # +# # +# This program is distributed in the hope that it will be useful, # +# but WITHOUT ANY WARRANTY; without even the implied warranty of # +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # +# GNU General Public License for more details. # +# # +# You should have received a copy of the GNU General Public License # +# along with this program. If not, see . # +########################################################################## +""" +All the tests +""" +import os +from tempfile import mkstemp + +import pytest +from PyQt5 import QtCore, QtWidgets + +from openlp.core.common.registry import Registry +from openlp.core.common.settings import Settings + + +@pytest.yield_fixture +def qapp(): + """An instance of QApplication""" + app = QtWidgets.QApplication([]) + yield app + del app + + +@pytest.yield_fixture +def settings(qapp): + """A Settings() instance""" + fd, ini_file = mkstemp('.ini') + Settings.set_filename(ini_file) + Registry.create() + Settings().setDefaultFormat(QtCore.QSettings.IniFormat) + # Needed on windows to make sure a Settings object is available during the tests + sets = Settings() + sets.setValue('themes/global theme', 'my_theme') + Registry().register('settings', set) + yield sets + del sets + os.close(fd) + os.unlink(Settings().fileName()) + + +@pytest.fixture +def registry(): + """An instance of the Registry""" + Registry.create() diff --git a/tests/functional/openlp_core/test_app.py b/tests/functional/openlp_core/test_app.py index 19ac7f9df..7507b5f70 100644 --- a/tests/functional/openlp_core/test_app.py +++ b/tests/functional/openlp_core/test_app.py @@ -19,6 +19,7 @@ # along with this program. If not, see . # ########################################################################## import sys + from unittest import TestCase, skip from unittest.mock import MagicMock, patch @@ -157,6 +158,8 @@ def test_parse_options_file_and_debug(): assert args.rargs == ['dummy_temp'], 'The service file should not be blank' +# Problem seems to be with the what the OpenLP object is defined. +# Running each test on its own is fine but as a block you get seg faults in strange places. @skip('Figure out why this is causing a segfault') class TestOpenLP(TestCase): """ diff --git a/tests/functional/openlp_core/ui/media/test_media.py b/tests/functional/openlp_core/ui/media/test_media.py index 77855518c..733969c28 100644 --- a/tests/functional/openlp_core/ui/media/test_media.py +++ b/tests/functional/openlp_core/ui/media/test_media.py @@ -21,155 +21,62 @@ """ Package to test the openlp.core.ui package. """ -from unittest import TestCase, skip -from unittest.mock import patch - -from PyQt5 import QtCore - from openlp.core.ui.media import parse_optical_path -from tests.helpers.testmixin import TestMixin -class TestMedia(TestCase, TestMixin): +def test_parse_optical_path_linux(): + """ + Test that test_parse_optical_path() parses a optical path with linux device path correctly + """ - @skip - def test_get_media_players_no_config(self): - """ - Test that when there's no config, get_media_players() returns an empty list of players (not a string) - """ - def value_results(key): - if key == 'media/players': - return '' - else: - return False + # GIVEN: An optical formatted path + org_title_track = 1 + org_audio_track = 2 + org_subtitle_track = -1 + org_start = 1234 + org_end = 4321 + org_name = 'test name' + org_device_path = '/dev/dvd' + path = 'optical:%d:%d:%d:%d:%d:%s:%s' % (org_title_track, org_audio_track, org_subtitle_track, + org_start, org_end, org_name, org_device_path) - # GIVEN: A mocked out Settings() object - with patch('openlp.core.ui.media.Settings.value') as mocked_value: - mocked_value.side_effect = value_results + # WHEN: parsing the path + (device_path, title_track, audio_track, subtitle_track, start, end, name) = parse_optical_path(path) - # WHEN: get_media_players() is called - used_players, overridden_player = 'vlc' + # THEN: The return values should match the original values + assert org_title_track == int(title_track), 'Returned title_track should match the original' + assert org_audio_track == audio_track, 'Returned audio_track should match the original' + assert org_subtitle_track == int(subtitle_track), 'Returned subtitle_track should match the original' + assert org_start == start, 'Returned start should match the original' + assert org_end == end, 'Returned end should match the original' + assert org_name == name, 'Returned end should match the original' + assert org_device_path == device_path, 'Returned device_path should match the original' - # THEN: the used_players should be an empty list, and the overridden player should be an empty string - assert [] == used_players, 'Used players should be an empty list' - assert '' == overridden_player, 'Overridden player should be an empty string' - @skip - def test_get_media_players_no_players(self): - """ - Test that when there's no players but overridden player is set, get_media_players() returns 'auto' - """ - def value_results(key): - if key == 'media/override player': - return QtCore.Qt.Checked - else: - return '' +def test_parse_optical_path_win(): + """ + Test that test_parse_optical_path() parses a optical path with windows device path correctly + """ - # GIVEN: A mocked out Settings() object - with patch('openlp.core.ui.media.Settings.value') as mocked_value: - mocked_value.side_effect = value_results + # GIVEN: An optical formatted path + org_title_track = 1 + org_audio_track = 2 + org_subtitle_track = -1 + org_start = 1234 + org_end = 4321 + org_name = 'test name' + org_device_path = 'D:' + path = 'optical:%d:%d:%d:%d:%d:%s:%s' % (org_title_track, org_audio_track, org_subtitle_track, + org_start, org_end, org_name, org_device_path) - # WHEN: get_media_players() is called - used_players, overridden_player = 'vlc' + # WHEN: parsing the path + (device_path, title_track, audio_track, subtitle_track, start, end, name) = parse_optical_path(path) - # THEN: the used_players should be an empty list, and the overridden player should be an empty string - assert [] == used_players, 'Used players should be an empty list' - assert 'auto' == overridden_player, 'Overridden player should be "auto"' - - @skip - def test_get_media_players_with_valid_list(self): - """ - Test that when get_media_players() is called the string list is interpreted correctly - """ - def value_results(key): - if key == 'media/players': - return '[vlc]' - else: - return False - - # GIVEN: A mocked out Settings() object - with patch('openlp.core.ui.media.Settings.value') as mocked_value: - mocked_value.side_effect = value_results - - # WHEN: get_media_players() is called - used_players = 'vlc' - - # THEN: the used_players should be an empty list, and the overridden player should be an empty string - assert ['vlc', 'webkit', 'system'] == used_players, 'Used players should be correct' - - @skip - def test_get_media_players_with_overridden_player(self): - """ - Test that when get_media_players() is called the overridden player is correctly set - """ - def value_results(key): - if key == 'media/players': - return '[vlc]' - else: - return QtCore.Qt.Checked - - # GIVEN: A mocked out Settings() object - with patch('openlp.core.ui.media.Settings.value') as mocked_value: - mocked_value.side_effect = value_results - - # WHEN: get_media_players() is called - used_players = 'vlc' - - # THEN: the used_players should be an empty list, and the overridden player should be an empty string - assert ['vlc'] == used_players, 'Used players should be correct' - - def test_parse_optical_path_linux(self): - """ - Test that test_parse_optical_path() parses a optical path with linux device path correctly - """ - - # GIVEN: An optical formatted path - org_title_track = 1 - org_audio_track = 2 - org_subtitle_track = -1 - org_start = 1234 - org_end = 4321 - org_name = 'test name' - org_device_path = '/dev/dvd' - path = 'optical:%d:%d:%d:%d:%d:%s:%s' % (org_title_track, org_audio_track, org_subtitle_track, - org_start, org_end, org_name, org_device_path) - - # WHEN: parsing the path - (device_path, title_track, audio_track, subtitle_track, start, end, name) = parse_optical_path(path) - - # THEN: The return values should match the original values - assert org_title_track == int(title_track), 'Returned title_track should match the original' - assert org_audio_track == audio_track, 'Returned audio_track should match the original' - assert org_subtitle_track == int(subtitle_track), 'Returned subtitle_track should match the original' - assert org_start == start, 'Returned start should match the original' - assert org_end == end, 'Returned end should match the original' - assert org_name == name, 'Returned end should match the original' - assert org_device_path == device_path, 'Returned device_path should match the original' - - def test_parse_optical_path_win(self): - """ - Test that test_parse_optical_path() parses a optical path with windows device path correctly - """ - - # GIVEN: An optical formatted path - org_title_track = 1 - org_audio_track = 2 - org_subtitle_track = -1 - org_start = 1234 - org_end = 4321 - org_name = 'test name' - org_device_path = 'D:' - path = 'optical:%d:%d:%d:%d:%d:%s:%s' % (org_title_track, org_audio_track, org_subtitle_track, - org_start, org_end, org_name, org_device_path) - - # WHEN: parsing the path - (device_path, title_track, audio_track, subtitle_track, start, end, name) = parse_optical_path(path) - - # THEN: The return values should match the original values - assert org_title_track == int(title_track), 'Returned title_track should match the original' - assert org_audio_track == audio_track, 'Returned audio_track should match the original' - assert org_subtitle_track == int(subtitle_track), 'Returned subtitle_track should match the original' - assert org_start == start, 'Returned start should match the original' - assert org_end == end, 'Returned end should match the original' - assert org_name == name, 'Returned end should match the original' - assert org_device_path == device_path, 'Returned device_path should match the original' + # THEN: The return values should match the original values + assert org_title_track == int(title_track), 'Returned title_track should match the original' + assert org_audio_track == audio_track, 'Returned audio_track should match the original' + assert org_subtitle_track == int(subtitle_track), 'Returned subtitle_track should match the original' + assert org_start == start, 'Returned start should match the original' + assert org_end == end, 'Returned end should match the original' + assert org_name == name, 'Returned end should match the original' + assert org_device_path == device_path, 'Returned device_path should match the original' diff --git a/tests/functional/openlp_core/ui/media/test_vlcplayer.py b/tests/functional/openlp_core/ui/media/test_vlcplayer.py index 2e48e526a..0b259bfce 100644 --- a/tests/functional/openlp_core/ui/media/test_vlcplayer.py +++ b/tests/functional/openlp_core/ui/media/test_vlcplayer.py @@ -23,915 +23,925 @@ Package to test the openlp.core.ui.media.vlcplayer package. """ import os import sys +import pytest from datetime import timedelta -from unittest import TestCase, skip from unittest.mock import MagicMock, call, patch from openlp.core.common.registry import Registry from openlp.core.ui.media import ItemMediaInfo, MediaState, MediaType from openlp.core.ui.media.vlcplayer import VlcPlayer, get_vlc from tests.helpers import MockDateTime -from tests.helpers.testmixin import TestMixin -class TestVLCPlayer(TestCase, TestMixin): +@pytest.yield_fixture +def vlc_env(): + """An instance of OpenLP""" + if 'VLC_PLUGIN_PATH' in os.environ: + del os.environ['VLC_PLUGIN_PATH'] + if 'openlp.core.ui.media.vendor.vlc' in sys.modules: + del sys.modules['openlp.core.ui.media.vendor.vlc'] + yield + MockDateTime.revert() + + +@patch.dict(os.environ) +@patch('openlp.core.ui.media.vlcplayer.is_macosx') +def test_not_osx_fix_vlc_22_plugin_path(mocked_is_macosx): """ - Test the functions in the :mod:`vlcplayer` module. + Test that on Linux or some other non-OS X we do not set the VLC plugin path """ - def setUp(self): - """ - Common setup for all the tests - """ - if 'VLC_PLUGIN_PATH' in os.environ: - del os.environ['VLC_PLUGIN_PATH'] - if 'openlp.core.ui.media.vendor.vlc' in sys.modules: - del sys.modules['openlp.core.ui.media.vendor.vlc'] - MockDateTime.revert() - - @skip('No way to test this') - @patch('openlp.core.ui.media.vlcplayer.vlc') - def test_get_vlc_fails_and_removes_module(self, mocked_vlc): - """ - Test that when the VLC import fails, it removes the module from sys.modules - """ - # GIVEN: We're on OS X and we don't have the VLC plugin path set - mocked_vlc.Instance.side_effect = NameError - mocked_vlc.libvlc_get_version.return_value = b'0.0.0' - - # WHEN: An checking if the player is available - get_vlc() - - # THEN: The extra environment variable should be there - assert 'openlp.core.ui.media.vendor.vlc' not in sys.modules - - @patch.dict(os.environ) - @patch('openlp.core.ui.media.vlcplayer.is_macosx') - def test_not_osx_fix_vlc_22_plugin_path(self, mocked_is_macosx): - """ - Test that on Linux or some other non-OS X we do not set the VLC plugin path - """ - # GIVEN: We're not on OS X and we don't have the VLC plugin path set - mocked_is_macosx.return_value = False - - # WHEN: An checking if the player is available - get_vlc() - - # THEN: The extra environment variable should NOT be there - assert 'VLC_PLUGIN_PATH' not in os.environ, 'The plugin path should NOT be in the environment variables' - - def test_init(self): - """ - Test that the VLC player class initialises correctly - """ - # GIVEN: A mocked out list of extensions - # TODO: figure out how to mock out the lists of extensions - - # WHEN: The VlcPlayer class is instantiated - vlc_player = VlcPlayer(None) - - # THEN: The correct variables are set - assert 'VLC' == vlc_player.original_name - assert '&VLC' == vlc_player.display_name - assert vlc_player.parent is None - assert vlc_player.can_folder is True - - @patch('openlp.core.ui.media.vlcplayer.is_win') - @patch('openlp.core.ui.media.vlcplayer.is_macosx') - @patch('openlp.core.ui.media.vlcplayer.get_vlc') - @patch('openlp.core.ui.media.vlcplayer.QtWidgets') - @patch('openlp.core.ui.media.vlcplayer.Settings') - def test_setup(self, MockedSettings, MockedQtWidgets, mocked_get_vlc, mocked_is_macosx, mocked_is_win): - """ - Test the setup method - """ - # GIVEN: A bunch of mocked out stuff and a VlcPlayer object - mocked_is_macosx.return_value = False - mocked_is_win.return_value = False - mocked_settings = MagicMock() - mocked_settings.value.return_value = '' - MockedSettings.return_value = mocked_settings - mocked_qframe = MagicMock() - mocked_qframe.winId.return_value = 2 - MockedQtWidgets.QFrame.NoFrame = 1 - MockedQtWidgets.QFrame.return_value = mocked_qframe - mocked_media_player_new = MagicMock() - mocked_instance = MagicMock() - mocked_instance.media_player_new.return_value = mocked_media_player_new - mocked_vlc = MagicMock() - mocked_vlc.Instance.return_value = mocked_instance - mocked_get_vlc.return_value = mocked_vlc - mocked_output_display = MagicMock() - mocked_controller = MagicMock() - mocked_controller.is_live = True - mocked_output_display.size.return_value = (10, 10) - vlc_player = VlcPlayer(None) - - # WHEN: setup() is run - vlc_player.setup(mocked_output_display, mocked_controller, True) - - # THEN: The VLC widget should be set up correctly - assert mocked_output_display.vlc_widget == mocked_qframe - mocked_qframe.setFrameStyle.assert_called_with(1) - mocked_settings.value.assert_any_call('advanced/hide mouse') - mocked_settings.value.assert_any_call('media/vlc arguments') - mocked_vlc.Instance.assert_called_with('--no-video-title-show ') - assert mocked_output_display.vlc_instance == mocked_instance - mocked_instance.media_player_new.assert_called_with() - assert mocked_output_display.vlc_media_player == mocked_media_player_new - mocked_output_display.size.assert_called_with() - mocked_qframe.resize.assert_called_with((10, 10)) - mocked_qframe.raise_.assert_called_with() - mocked_qframe.hide.assert_called_with() - mocked_media_player_new.set_xwindow.assert_called_with(2) - assert vlc_player.has_own_widget is True - - @patch('openlp.core.ui.media.vlcplayer.is_win') - @patch('openlp.core.ui.media.vlcplayer.is_macosx') - @patch('openlp.core.ui.media.vlcplayer.get_vlc') - @patch('openlp.core.ui.media.vlcplayer.QtWidgets') - @patch('openlp.core.ui.media.vlcplayer.Settings') - def test_setup_has_audio(self, MockedSettings, MockedQtWidgets, mocked_get_vlc, mocked_is_macosx, mocked_is_win): - """ - Test the setup method when has_audio is True - """ - # GIVEN: A bunch of mocked out stuff and a VlcPlayer object - mocked_is_macosx.return_value = False - mocked_is_win.return_value = False - mocked_settings = MagicMock() - mocked_settings.value.return_value = '' - MockedSettings.return_value = mocked_settings - mocked_qframe = MagicMock() - mocked_qframe.winId.return_value = 2 - MockedQtWidgets.QFrame.NoFrame = 1 - MockedQtWidgets.QFrame.return_value = mocked_qframe - mocked_media_player_new = MagicMock() - mocked_instance = MagicMock() - mocked_instance.media_player_new.return_value = mocked_media_player_new - mocked_vlc = MagicMock() - mocked_vlc.Instance.return_value = mocked_instance - mocked_get_vlc.return_value = mocked_vlc - mocked_output_display = MagicMock() - mocked_controller = MagicMock() - mocked_controller.is_live = True - mocked_output_display.size.return_value = (10, 10) - vlc_player = VlcPlayer(None) - - # WHEN: setup() is run - vlc_player.setup(mocked_output_display, mocked_controller, True) - - # THEN: The VLC instance should be created with the correct options - mocked_vlc.Instance.assert_called_with('--no-video-title-show ') - - @patch('openlp.core.ui.media.vlcplayer.is_win') - @patch('openlp.core.ui.media.vlcplayer.is_macosx') - @patch('openlp.core.ui.media.vlcplayer.get_vlc') - @patch('openlp.core.ui.media.vlcplayer.QtWidgets') - @patch('openlp.core.ui.media.vlcplayer.Settings') - def test_setup_visible_mouse(self, MockedSettings, MockedQtWidgets, mocked_get_vlc, mocked_is_macosx, - mocked_is_win): - """ - Test the setup method when Settings().value("hide mouse") is False - """ - # GIVEN: A bunch of mocked out stuff and a VlcPlayer object - mocked_is_macosx.return_value = False - mocked_is_win.return_value = False - mocked_settings = MagicMock() - mocked_settings.value.return_value = '' - MockedSettings.return_value = mocked_settings - mocked_qframe = MagicMock() - mocked_qframe.winId.return_value = 2 - MockedQtWidgets.QFrame.NoFrame = 1 - MockedQtWidgets.QFrame.return_value = mocked_qframe - mocked_media_player_new = MagicMock() - mocked_instance = MagicMock() - mocked_instance.media_player_new.return_value = mocked_media_player_new - mocked_vlc = MagicMock() - mocked_vlc.Instance.return_value = mocked_instance - mocked_get_vlc.return_value = mocked_vlc - mocked_output_display = MagicMock() - mocked_controller = MagicMock() - mocked_controller.is_live = True - mocked_output_display.size.return_value = (10, 10) - vlc_player = VlcPlayer(None) - - # WHEN: setup() is run - vlc_player.setup(mocked_output_display, mocked_controller, True) - - # THEN: The VLC instance should be created with the correct options - mocked_vlc.Instance.assert_called_with('--no-video-title-show ') - - @patch('openlp.core.ui.media.vlcplayer.is_win') - @patch('openlp.core.ui.media.vlcplayer.is_macosx') - @patch('openlp.core.ui.media.vlcplayer.get_vlc') - @patch('openlp.core.ui.media.vlcplayer.QtWidgets') - @patch('openlp.core.ui.media.vlcplayer.Settings') - def test_setup_windows(self, MockedSettings, MockedQtWidgets, mocked_get_vlc, mocked_is_macosx, mocked_is_win): - """ - Test the setup method when running on Windows - """ - # GIVEN: A bunch of mocked out stuff and a VlcPlayer object - mocked_is_macosx.return_value = False - mocked_is_win.return_value = True - mocked_settings = MagicMock() - mocked_settings.value.return_value = False - MockedSettings.return_value = mocked_settings - mocked_qframe = MagicMock() - mocked_qframe.winId.return_value = 2 - MockedQtWidgets.QFrame.NoFrame = 1 - MockedQtWidgets.QFrame.return_value = mocked_qframe - mocked_media_player_new = MagicMock() - mocked_instance = MagicMock() - mocked_instance.media_player_new.return_value = mocked_media_player_new - mocked_vlc = MagicMock() - mocked_vlc.Instance.return_value = mocked_instance - mocked_get_vlc.return_value = mocked_vlc - mocked_output_display = MagicMock() - mocked_controller = MagicMock() - mocked_controller.is_live = True - mocked_output_display.size.return_value = (10, 10) - vlc_player = VlcPlayer(None) - - # WHEN: setup() is run - vlc_player.setup(mocked_output_display, mocked_controller, True) - - # THEN: set_hwnd should be called - mocked_media_player_new.set_hwnd.assert_called_with(2) - - @patch('openlp.core.ui.media.vlcplayer.is_win') - @patch('openlp.core.ui.media.vlcplayer.is_macosx') - @patch('openlp.core.ui.media.vlcplayer.get_vlc') - @patch('openlp.core.ui.media.vlcplayer.QtWidgets') - @patch('openlp.core.ui.media.vlcplayer.Settings') - def test_setup_osx(self, MockedSettings, MockedQtWidgets, mocked_get_vlc, mocked_is_macosx, mocked_is_win): - """ - Test the setup method when running on OS X - """ - # GIVEN: A bunch of mocked out stuff and a VlcPlayer object - mocked_is_macosx.return_value = True - mocked_is_win.return_value = False - mocked_settings = MagicMock() - mocked_settings.value.return_value = False - MockedSettings.return_value = mocked_settings - mocked_qframe = MagicMock() - mocked_qframe.winId.return_value = 2 - MockedQtWidgets.QFrame.NoFrame = 1 - MockedQtWidgets.QFrame.return_value = mocked_qframe - mocked_media_player_new = MagicMock() - mocked_instance = MagicMock() - mocked_instance.media_player_new.return_value = mocked_media_player_new - mocked_vlc = MagicMock() - mocked_vlc.Instance.return_value = mocked_instance - mocked_get_vlc.return_value = mocked_vlc - mocked_output_display = MagicMock() - mocked_controller = MagicMock() - mocked_controller.is_live = True - mocked_output_display.size.return_value = (10, 10) - vlc_player = VlcPlayer(None) - - # WHEN: setup() is run - vlc_player.setup(mocked_output_display, mocked_controller, True) - - # THEN: set_nsobject should be called - mocked_media_player_new.set_nsobject.assert_called_with(2) - - @patch('openlp.core.ui.media.vlcplayer.get_vlc') - def test_check_available(self, mocked_get_vlc): - """ - Check that when the "vlc" module is available, then VLC is set as available - """ - # GIVEN: A mocked out get_vlc() method and a VlcPlayer instance - mocked_get_vlc.return_value = MagicMock() - vlc_player = VlcPlayer(None) - - # WHEN: vlc - is_available = vlc_player.check_available() - - # THEN: VLC should be available - assert is_available is True - - @patch('openlp.core.ui.media.vlcplayer.get_vlc') - def test_check_not_available(self, mocked_get_vlc): - """ - Check that when the "vlc" module is not available, then VLC is set as unavailable - """ - # GIVEN: A mocked out get_vlc() method and a VlcPlayer instance - mocked_get_vlc.return_value = None - vlc_player = VlcPlayer(None) - - # WHEN: vlc - is_available = vlc_player.check_available() - - # THEN: VLC should NOT be available - assert is_available is False - - @patch('openlp.core.ui.media.vlcplayer.get_vlc') - @patch('openlp.core.ui.media.vlcplayer.os.path.normcase') - def test_load(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_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() - mocked_media = MagicMock() - mocked_media.get_duration.return_value = 10000 - mocked_controller.vlc_instance.media_new_path.return_value = mocked_vlc_media - mocked_controller.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_controller, mocked_display, media_path) - - # THEN: The video should be loaded - mocked_normcase.assert_called_with(media_path) - mocked_controller.vlc_instance.media_new_path.assert_called_with(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 - - @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(self, 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 - - @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(self, mocked_normcase, mocked_get_vlc, mocked_is_win): - """ - Test loading an audio CD into VLC on Windows - """ - # GIVEN: A mocked out get_vlc() method - mocked_is_win.return_value = True - 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.file_info.absoluteFilePath.return_value = media_path - 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 - - @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_no_tracks(self, mocked_normcase, mocked_get_vlc, mocked_is_win): - """ - Test loading an audio CD that has no tracks 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.file_info.absoluteFilePath.return_value = media_path - mocked_controller.media_info.title_track = 1 - mocked_vlc_media = MagicMock() - mocked_vlc_media_player = MagicMock() - mocked_controller.vlc_media = mocked_vlc_media - mocked_controller.vlc_media_player = mocked_vlc_media_player - 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 = 0 - 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'), 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 - assert 0 == mocked_subitems.item_at_index.call_count - mocked_controller.vlc_media_player.set_media.assert_called_with(mocked_vlc_media) - assert 0 == mocked_vlc_media.parse.call_count - assert result is False - - @patch('openlp.core.ui.media.vlcplayer.get_vlc') - @patch('openlp.core.ui.media.vlcplayer.datetime', MockDateTime) - def test_media_state_wait(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 - assert result is True - - @patch('openlp.core.ui.media.vlcplayer.get_vlc') - @patch('openlp.core.ui.media.vlcplayer.datetime', MockDateTime) - 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 - - @patch('openlp.core.ui.media.vlcplayer.get_vlc') - @patch('openlp.core.ui.media.vlcplayer.datetime', MockDateTime) - 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 - assert result is False - - def test_resize(self): - """ - Test resizing the player - """ - # GIVEN: A display object and a VlcPlayer instance - mocked_controller = MagicMock() - mocked_controller.preview_display.size.return_value = (10, 10) - mocked_controller.is_live = False - vlc_player = VlcPlayer(None) - - # WHEN: resize is called - vlc_player.resize(mocked_controller) - - # THEN: The right methods should have been called - mocked_controller.preview_display.size.assert_called_with() - mocked_controller.vlc_widget.resize.assert_called_with((10, 10)) - - @patch('openlp.core.ui.media.vlcplayer.threading') - @patch('openlp.core.ui.media.vlcplayer.get_vlc') - 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_display = MagicMock() - mocked_controller = MagicMock() - mocked_media = MagicMock() - mocked_media.get_duration.return_value = 50000 - mocked_controller.media_info.start_time = 0 - mocked_controller.media_info.media_type = MediaType.Video - 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: - 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() - mocked_controller.vlc_widget.raise_.assert_called_with() - assert result is True, 'The value returned from play() should be True' - - @patch('openlp.core.ui.media.vlcplayer.threading') - @patch('openlp.core.ui.media.vlcplayer.get_vlc') - 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_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 - - @patch('openlp.core.ui.media.vlcplayer.threading') - @patch('openlp.core.ui.media.vlcplayer.get_vlc') - def test_play_dvd(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_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' - - @patch('openlp.core.ui.media.vlcplayer.get_vlc') - def test_pause(self, 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() - - @patch('openlp.core.ui.media.vlcplayer.get_vlc') - def test_pause_not_playing(self, mocked_get_vlc): - """ - Test the pause method when the player is not playing - """ - # GIVEN: A mocked out get_vlc method - mocked_vlc = MagicMock() - mocked_vlc.State.Playing = 1 - mocked_get_vlc.return_value = mocked_vlc - mocked_display = MagicMock() - mocked_display.vlc_media.get_state.return_value = 2 - vlc_player = VlcPlayer(None) - - # WHEN: The media is paused + # GIVEN: We're not on OS X and we don't have the VLC plugin path set + mocked_is_macosx.return_value = False + + # WHEN: An checking if the player is available + get_vlc() + + # THEN: The extra environment variable should NOT be there + assert 'VLC_PLUGIN_PATH' not in os.environ, 'The plugin path should NOT be in the environment variables' + + +def test_init(): + """ + Test that the VLC player class initialises correctly + """ + # GIVEN: A mocked out list of extensions + # TODO: figure out how to mock out the lists of extensions + + # WHEN: The VlcPlayer class is instantiated + vlc_player = VlcPlayer(None) + + # THEN: The correct variables are set + assert 'VLC' == vlc_player.original_name + assert '&VLC' == vlc_player.display_name + assert vlc_player.parent is None + assert vlc_player.can_folder is True + + +@patch('openlp.core.ui.media.vlcplayer.is_win') +@patch('openlp.core.ui.media.vlcplayer.is_macosx') +@patch('openlp.core.ui.media.vlcplayer.get_vlc') +@patch('openlp.core.ui.media.vlcplayer.QtWidgets') +@patch('openlp.core.ui.media.vlcplayer.Settings') +def test_setup(MockedSettings, MockedQtWidgets, mocked_get_vlc, mocked_is_macosx, mocked_is_win): + """ + Test the setup method + """ + # GIVEN: A bunch of mocked out stuff and a VlcPlayer object + mocked_is_macosx.return_value = False + mocked_is_win.return_value = False + mocked_settings = MagicMock() + mocked_settings.value.return_value = '' + MockedSettings.return_value = mocked_settings + mocked_qframe = MagicMock() + mocked_qframe.winId.return_value = 2 + MockedQtWidgets.QFrame.NoFrame = 1 + MockedQtWidgets.QFrame.return_value = mocked_qframe + mocked_media_player_new = MagicMock() + mocked_instance = MagicMock() + mocked_instance.media_player_new.return_value = mocked_media_player_new + mocked_vlc = MagicMock() + mocked_vlc.Instance.return_value = mocked_instance + mocked_get_vlc.return_value = mocked_vlc + mocked_output_display = MagicMock() + mocked_controller = MagicMock() + mocked_controller.is_live = True + mocked_output_display.size.return_value = (10, 10) + vlc_player = VlcPlayer(None) + + # WHEN: setup() is run + vlc_player.setup(mocked_output_display, mocked_controller, True) + + # THEN: The VLC widget should be set up correctly + assert mocked_output_display.vlc_widget == mocked_qframe + mocked_qframe.setFrameStyle.assert_called_with(1) + mocked_settings.value.assert_any_call('advanced/hide mouse') + mocked_settings.value.assert_any_call('media/vlc arguments') + mocked_vlc.Instance.assert_called_with('--no-video-title-show ') + assert mocked_output_display.vlc_instance == mocked_instance + mocked_instance.media_player_new.assert_called_with() + assert mocked_output_display.vlc_media_player == mocked_media_player_new + mocked_output_display.size.assert_called_with() + mocked_qframe.resize.assert_called_with((10, 10)) + mocked_qframe.raise_.assert_called_with() + mocked_qframe.hide.assert_called_with() + mocked_media_player_new.set_xwindow.assert_called_with(2) + assert vlc_player.has_own_widget is True + + +@patch('openlp.core.ui.media.vlcplayer.is_win') +@patch('openlp.core.ui.media.vlcplayer.is_macosx') +@patch('openlp.core.ui.media.vlcplayer.get_vlc') +@patch('openlp.core.ui.media.vlcplayer.QtWidgets') +@patch('openlp.core.ui.media.vlcplayer.Settings') +def test_setup_has_audio(MockedSettings, MockedQtWidgets, mocked_get_vlc, mocked_is_macosx, mocked_is_win): + """ + Test the setup method when has_audio is True + """ + # GIVEN: A bunch of mocked out stuff and a VlcPlayer object + mocked_is_macosx.return_value = False + mocked_is_win.return_value = False + mocked_settings = MagicMock() + mocked_settings.value.return_value = '' + MockedSettings.return_value = mocked_settings + mocked_qframe = MagicMock() + mocked_qframe.winId.return_value = 2 + MockedQtWidgets.QFrame.NoFrame = 1 + MockedQtWidgets.QFrame.return_value = mocked_qframe + mocked_media_player_new = MagicMock() + mocked_instance = MagicMock() + mocked_instance.media_player_new.return_value = mocked_media_player_new + mocked_vlc = MagicMock() + mocked_vlc.Instance.return_value = mocked_instance + mocked_get_vlc.return_value = mocked_vlc + mocked_output_display = MagicMock() + mocked_controller = MagicMock() + mocked_controller.is_live = True + mocked_output_display.size.return_value = (10, 10) + vlc_player = VlcPlayer(None) + + # WHEN: setup() is run + vlc_player.setup(mocked_output_display, mocked_controller, True) + + # THEN: The VLC instance should be created with the correct options + mocked_vlc.Instance.assert_called_with('--no-video-title-show ') + + +@patch('openlp.core.ui.media.vlcplayer.is_win') +@patch('openlp.core.ui.media.vlcplayer.is_macosx') +@patch('openlp.core.ui.media.vlcplayer.get_vlc') +@patch('openlp.core.ui.media.vlcplayer.QtWidgets') +@patch('openlp.core.ui.media.vlcplayer.Settings') +def test_setup_visible_mouse(MockedSettings, MockedQtWidgets, mocked_get_vlc, mocked_is_macosx, mocked_is_win): + """ + Test the setup method when Settings().value("hide mouse") is False + """ + # GIVEN: A bunch of mocked out stuff and a VlcPlayer object + mocked_is_macosx.return_value = False + mocked_is_win.return_value = False + mocked_settings = MagicMock() + mocked_settings.value.return_value = '' + MockedSettings.return_value = mocked_settings + mocked_qframe = MagicMock() + mocked_qframe.winId.return_value = 2 + MockedQtWidgets.QFrame.NoFrame = 1 + MockedQtWidgets.QFrame.return_value = mocked_qframe + mocked_media_player_new = MagicMock() + mocked_instance = MagicMock() + mocked_instance.media_player_new.return_value = mocked_media_player_new + mocked_vlc = MagicMock() + mocked_vlc.Instance.return_value = mocked_instance + mocked_get_vlc.return_value = mocked_vlc + mocked_output_display = MagicMock() + mocked_controller = MagicMock() + mocked_controller.is_live = True + mocked_output_display.size.return_value = (10, 10) + vlc_player = VlcPlayer(None) + + # WHEN: setup() is run + vlc_player.setup(mocked_output_display, mocked_controller, True) + + # THEN: The VLC instance should be created with the correct options + mocked_vlc.Instance.assert_called_with('--no-video-title-show ') + + +@patch('openlp.core.ui.media.vlcplayer.is_win') +@patch('openlp.core.ui.media.vlcplayer.is_macosx') +@patch('openlp.core.ui.media.vlcplayer.get_vlc') +@patch('openlp.core.ui.media.vlcplayer.QtWidgets') +@patch('openlp.core.ui.media.vlcplayer.Settings') +def test_setup_windows(MockedSettings, MockedQtWidgets, mocked_get_vlc, mocked_is_macosx, mocked_is_win): + """ + Test the setup method when running on Windows + """ + # GIVEN: A bunch of mocked out stuff and a VlcPlayer object + mocked_is_macosx.return_value = False + mocked_is_win.return_value = True + mocked_settings = MagicMock() + mocked_settings.value.return_value = False + MockedSettings.return_value = mocked_settings + mocked_qframe = MagicMock() + mocked_qframe.winId.return_value = 2 + MockedQtWidgets.QFrame.NoFrame = 1 + MockedQtWidgets.QFrame.return_value = mocked_qframe + mocked_media_player_new = MagicMock() + mocked_instance = MagicMock() + mocked_instance.media_player_new.return_value = mocked_media_player_new + mocked_vlc = MagicMock() + mocked_vlc.Instance.return_value = mocked_instance + mocked_get_vlc.return_value = mocked_vlc + mocked_output_display = MagicMock() + mocked_controller = MagicMock() + mocked_controller.is_live = True + mocked_output_display.size.return_value = (10, 10) + vlc_player = VlcPlayer(None) + + # WHEN: setup() is run + vlc_player.setup(mocked_output_display, mocked_controller, True) + + # THEN: set_hwnd should be called + mocked_media_player_new.set_hwnd.assert_called_with(2) + + +@patch('openlp.core.ui.media.vlcplayer.is_win') +@patch('openlp.core.ui.media.vlcplayer.is_macosx') +@patch('openlp.core.ui.media.vlcplayer.get_vlc') +@patch('openlp.core.ui.media.vlcplayer.QtWidgets') +@patch('openlp.core.ui.media.vlcplayer.Settings') +def test_setup_osx(MockedSettings, MockedQtWidgets, mocked_get_vlc, mocked_is_macosx, mocked_is_win): + """ + Test the setup method when running on OS X + """ + # GIVEN: A bunch of mocked out stuff and a VlcPlayer object + mocked_is_macosx.return_value = True + mocked_is_win.return_value = False + mocked_settings = MagicMock() + mocked_settings.value.return_value = False + MockedSettings.return_value = mocked_settings + mocked_qframe = MagicMock() + mocked_qframe.winId.return_value = 2 + MockedQtWidgets.QFrame.NoFrame = 1 + MockedQtWidgets.QFrame.return_value = mocked_qframe + mocked_media_player_new = MagicMock() + mocked_instance = MagicMock() + mocked_instance.media_player_new.return_value = mocked_media_player_new + mocked_vlc = MagicMock() + mocked_vlc.Instance.return_value = mocked_instance + mocked_get_vlc.return_value = mocked_vlc + mocked_output_display = MagicMock() + mocked_controller = MagicMock() + mocked_controller.is_live = True + mocked_output_display.size.return_value = (10, 10) + vlc_player = VlcPlayer(None) + + # WHEN: setup() is run + vlc_player.setup(mocked_output_display, mocked_controller, True) + + # THEN: set_nsobject should be called + mocked_media_player_new.set_nsobject.assert_called_with(2) + + +@patch('openlp.core.ui.media.vlcplayer.get_vlc') +def test_check_available(mocked_get_vlc): + """ + Check that when the "vlc" module is available, then VLC is set as available + """ + # GIVEN: A mocked out get_vlc() method and a VlcPlayer instance + mocked_get_vlc.return_value = MagicMock() + vlc_player = VlcPlayer(None) + + # WHEN: vlc + is_available = vlc_player.check_available() + + # THEN: VLC should be available + assert is_available is True + + +@patch('openlp.core.ui.media.vlcplayer.get_vlc') +def test_check_not_available(mocked_get_vlc): + """ + Check that when the "vlc" module is not available, then VLC is set as unavailable + """ + # GIVEN: A mocked out get_vlc() method and a VlcPlayer instance + mocked_get_vlc.return_value = None + vlc_player = VlcPlayer(None) + + # WHEN: vlc + is_available = vlc_player.check_available() + + # THEN: VLC should NOT be available + assert is_available is False + + +@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): + """ + 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_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() + mocked_media = MagicMock() + mocked_media.get_duration.return_value = 10000 + mocked_controller.vlc_instance.media_new_path.return_value = mocked_vlc_media + mocked_controller.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_controller, mocked_display, media_path) + + # THEN: The video should be loaded + mocked_normcase.assert_called_with(media_path) + mocked_controller.vlc_instance.media_new_path.assert_called_with(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 + + +@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): + """ + 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 + + +@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): + """ + Test loading an audio CD into VLC on Windows + """ + # GIVEN: A mocked out get_vlc() method + mocked_is_win.return_value = True + 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.file_info.absoluteFilePath.return_value = media_path + 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 + + +@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_no_tracks(mocked_normcase, mocked_get_vlc, mocked_is_win): + """ + Test loading an audio CD that has no tracks 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.file_info.absoluteFilePath.return_value = media_path + mocked_controller.media_info.title_track = 1 + mocked_vlc_media = MagicMock() + mocked_vlc_media_player = MagicMock() + mocked_controller.vlc_media = mocked_vlc_media + mocked_controller.vlc_media_player = mocked_vlc_media_player + 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 = 0 + 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'), 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 + assert 0 == mocked_subitems.item_at_index.call_count + mocked_controller.vlc_media_player.set_media.assert_called_with(mocked_vlc_media) + assert 0 == mocked_vlc_media.parse.call_count + assert result is False + + +@patch('openlp.core.ui.media.vlcplayer.get_vlc') +@patch('openlp.core.ui.media.vlcplayer.datetime', MockDateTime) +def test_media_state_wait(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 + assert result is True + + +@patch('openlp.core.ui.media.vlcplayer.get_vlc') +@patch('openlp.core.ui.media.vlcplayer.datetime', MockDateTime) +def test_media_state_wait_error(mocked_get_vlc, vlc_env): + """ + 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 + + +@patch('openlp.core.ui.media.vlcplayer.get_vlc') +@patch('openlp.core.ui.media.vlcplayer.datetime', MockDateTime) +def test_media_state_wait_times_out(mocked_get_vlc, vlc_env): + """ + 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 + assert result is False + + +def test_resize(): + """ + Test resizing the player + """ + # GIVEN: A display object and a VlcPlayer instance + mocked_controller = MagicMock() + mocked_controller.preview_display.size.return_value = (10, 10) + mocked_controller.is_live = False + vlc_player = VlcPlayer(None) + + # WHEN: resize is called + vlc_player.resize(mocked_controller) + + # THEN: The right methods should have been called + mocked_controller.preview_display.size.assert_called_with() + mocked_controller.vlc_widget.resize.assert_called_with((10, 10)) + + +@patch('openlp.core.ui.media.vlcplayer.threading') +@patch('openlp.core.ui.media.vlcplayer.get_vlc') +def test_play(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_display = MagicMock() + mocked_controller = MagicMock() + mocked_media = MagicMock() + mocked_media.get_duration.return_value = 50000 + mocked_controller.media_info.start_time = 0 + mocked_controller.media_info.media_type = MediaType.Video + 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: + 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() + mocked_controller.vlc_widget.raise_.assert_called_with() + assert result is True, 'The value returned from play() should be True' + + +@patch('openlp.core.ui.media.vlcplayer.threading') +@patch('openlp.core.ui.media.vlcplayer.get_vlc') +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 + + +@patch('openlp.core.ui.media.vlcplayer.threading') +@patch('openlp.core.ui.media.vlcplayer.get_vlc') +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' + + +@patch('openlp.core.ui.media.vlcplayer.get_vlc') +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() - assert 0 == mocked_display.vlc_media_player.pause.call_count + # 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() - @patch('openlp.core.ui.media.vlcplayer.get_vlc') - 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) +@patch('openlp.core.ui.media.vlcplayer.get_vlc') +def test_pause_not_playing(mocked_get_vlc): + """ + Test the pause method when the player is not playing + """ + # GIVEN: A mocked out get_vlc method + mocked_vlc = MagicMock() + mocked_vlc.State.Playing = 1 + mocked_get_vlc.return_value = mocked_vlc + mocked_display = MagicMock() + mocked_display.vlc_media.get_state.return_value = 2 + vlc_player = VlcPlayer(None) - # 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 is not vlc_player.state + # WHEN: The media is paused + vlc_player.pause(mocked_display) - @patch('openlp.core.ui.media.vlcplayer.threading') - def test_stop(self, mocked_threading): - """ - Test stopping the current item - """ - # GIVEN: A display object and a VlcPlayer instance and some mocked threads - mocked_thread = MagicMock() - mocked_threading.Thread.return_value = mocked_thread - mocked_stop = MagicMock() - mocked_display = MagicMock() - mocked_display.vlc_media_player.stop = mocked_stop - vlc_player = VlcPlayer(None) + # THEN: The pause method should exit early + mocked_display.vlc_media.get_state.assert_called_with() + assert 0 == mocked_display.vlc_media_player.pause.call_count - # WHEN: stop is called - vlc_player.stop(mocked_display) - # THEN: A thread should have been started to stop VLC - mocked_threading.Thread.assert_called_with(target=mocked_stop) - mocked_thread.start.assert_called_with() - assert MediaState.Stopped == vlc_player.get_live_state() +@patch('openlp.core.ui.media.vlcplayer.get_vlc') +def test_pause_fail(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) - def test_volume(self): - """ - Test setting the volume - """ - # GIVEN: A display object and a VlcPlayer instance - mocked_display = MagicMock() - mocked_display.has_audio = True - 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) - # WHEN: The volume is set - vlc_player.volume(mocked_display, 10) + # 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 is not vlc_player.state - # THEN: The volume should have been set - mocked_display.vlc_media_player.audio_set_volume.assert_called_with(10) - def test_seek_unseekable_media(self): - """ - Test seeking something that can't be seeked - """ - # GIVEN: Unseekable media - mocked_display = MagicMock() - mocked_display.controller.media_info.media_type = MediaType.Audio - mocked_display.vlc_media_player.is_seekable.return_value = False - vlc_player = VlcPlayer(None) +@patch('openlp.core.ui.media.vlcplayer.threading') +def test_stop(mocked_threading): + """ + Test stopping the current item + """ + # GIVEN: A display object and a VlcPlayer instance and some mocked threads + mocked_thread = MagicMock() + mocked_threading.Thread.return_value = mocked_thread + mocked_stop = MagicMock() + mocked_display = MagicMock() + mocked_display.vlc_media_player.stop = mocked_stop + vlc_player = VlcPlayer(None) - # WHEN: seek() is called - vlc_player.seek(mocked_display, 100) + # WHEN: stop is called + vlc_player.stop(mocked_display) - # THEN: nothing should happen - mocked_display.vlc_media_player.is_seekable.assert_called_with() - assert 0 == mocked_display.vlc_media_player.set_time.call_count + # THEN: A thread should have been started to stop VLC + mocked_threading.Thread.assert_called_with(target=mocked_stop) + mocked_thread.start.assert_called_with() + assert MediaState.Stopped == vlc_player.get_live_state() - def test_seek_seekable_media(self): - """ - Test seeking something that is seekable, but not a DVD - """ - # GIVEN: Unseekable media - mocked_display = MagicMock() - mocked_display.controller.media_info.media_type = MediaType.Audio - mocked_display.vlc_media_player.is_seekable.return_value = True - vlc_player = VlcPlayer(None) - # WHEN: seek() is called - vlc_player.seek(mocked_display, 100) +def test_volume(): + """ + Test setting the volume + """ + # GIVEN: A display object and a VlcPlayer instance + mocked_display = MagicMock() + mocked_display.has_audio = True + vlc_player = VlcPlayer(None) - # THEN: nothing should happen - mocked_display.vlc_media_player.is_seekable.assert_called_with() - mocked_display.vlc_media_player.set_time.assert_called_with(100) + # WHEN: The volume is set + vlc_player.volume(mocked_display, 10) - def test_seek_dvd(self): - """ - Test seeking a DVD - """ - # GIVEN: Unseekable media - mocked_display = MagicMock() - mocked_display.controller.media_info.media_type = MediaType.DVD - mocked_display.vlc_media_player.is_seekable.return_value = True - mocked_display.controller.media_info.start_time = 3000 - vlc_player = VlcPlayer(None) + # THEN: The volume should have been set + mocked_display.vlc_media_player.audio_set_volume.assert_called_with(10) - # WHEN: seek() is called - vlc_player.seek(mocked_display, 2000) - # THEN: nothing should happen - mocked_display.vlc_media_player.is_seekable.assert_called_with() - mocked_display.vlc_media_player.set_time.assert_called_with(2000) +def test_seek_unseekable_media(): + """ + Test seeking something that can't be seeked + """ + # GIVEN: Unseekable media + mocked_display = MagicMock() + mocked_display.controller.media_info.media_type = MediaType.Audio + mocked_display.vlc_media_player.is_seekable.return_value = False + vlc_player = VlcPlayer(None) - def test_reset(self): - """ - Test the reset() method - """ - # GIVEN: Some mocked out stuff - mocked_display = MagicMock() - vlc_player = VlcPlayer(None) + # WHEN: seek() is called + vlc_player.seek(mocked_display, 100) - # WHEN: reset() is called - vlc_player.reset(mocked_display) + # THEN: nothing should happen + mocked_display.vlc_media_player.is_seekable.assert_called_with() + assert 0 == mocked_display.vlc_media_player.set_time.call_count - # THEN: The media should be stopped and invisible - mocked_display.vlc_media_player.stop.assert_called_with() - mocked_display.vlc_widget.setVisible.assert_called_with(False) - assert MediaState.Off == vlc_player.get_live_state() - def test_set_visible_has_own_widget(self): - """ - Test the set_visible() method when the player has its own widget - """ - # GIVEN: Some mocked out stuff - mocked_display = MagicMock() - vlc_player = VlcPlayer(None) - vlc_player.has_own_widget = True +def test_seek_seekable_media(): + """ + Test seeking something that is seekable, but not a DVD + """ + # GIVEN: Unseekable media + mocked_display = MagicMock() + mocked_display.controller.media_info.media_type = MediaType.Audio + mocked_display.vlc_media_player.is_seekable.return_value = True + vlc_player = VlcPlayer(None) - # WHEN: reset() is called - vlc_player.set_visible(mocked_display, True) + # WHEN: seek() is called + vlc_player.seek(mocked_display, 100) - # THEN: The media should be stopped and invsibile - mocked_display.vlc_widget.setVisible.assert_called_with(True) + # THEN: nothing should happen + mocked_display.vlc_media_player.is_seekable.assert_called_with() + mocked_display.vlc_media_player.set_time.assert_called_with(100) - @patch('openlp.core.ui.media.vlcplayer.get_vlc') - def test_update_ui(self, mocked_get_vlc): - """ - Test updating the UI - """ - # 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.end_time = 300 - mocked_controller.seek_slider.isSliderDown.return_value = False - mocked_display = MagicMock() - mocked_controller.vlc_media.get_state.return_value = 1 - mocked_controller.vlc_media_player.get_time.return_value = 400000 - 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_controller, mocked_display) +def test_seek_dvd(): + """ + Test seeking a DVD + """ + # GIVEN: Unseekable media + mocked_display = MagicMock() + mocked_display.controller.media_info.media_type = MediaType.DVD + mocked_display.vlc_media_player.is_seekable.return_value = True + mocked_display.controller.media_info.start_time = 3000 + vlc_player = VlcPlayer(None) - # THEN: Certain methods should be called - mocked_stop.assert_called_with(mocked_controller) - assert 2 == mocked_stop.call_count - mocked_controller.vlc_media_player.get_time.assert_called_with() - mocked_set_visible.assert_called_with(mocked_controller, False) - mocked_controller.seek_slider.setSliderPosition.assert_called_with(400000) - expected_calls = [call(True), call(False)] - assert expected_calls == mocked_controller.seek_slider.blockSignals.call_args_list + # WHEN: seek() is called + vlc_player.seek(mocked_display, 2000) - @patch('openlp.core.ui.media.vlcplayer.get_vlc') - 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 = ItemMediaInfo() - 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_controller.vlc_media.get_state.return_value = 1 - mocked_controller.vlc_media_player.get_time.return_value = 300 - mocked_controller.media_info.media_type = MediaType.DVD - vlc_player = VlcPlayer(None) + # THEN: nothing should happen + mocked_display.vlc_media_player.is_seekable.assert_called_with() + mocked_display.vlc_media_player.set_time.assert_called_with(2000) - # WHEN: update_ui() is called - with patch.object(vlc_player, 'stop') as mocked_stop: - vlc_player.update_ui(mocked_controller, mocked_display) - # THEN: Certain methods should be called - mocked_stop.assert_called_with(mocked_controller) - assert 1 == mocked_stop.call_count - mocked_controller.vlc_media_player.get_time.assert_called_with() - mocked_controller.seek_slider.setSliderPosition.assert_called_with(200) - expected_calls = [call(True), call(False)] - assert expected_calls == mocked_controller.seek_slider.blockSignals.call_args_list +def test_reset(): + """ + Test the reset() method + """ + # GIVEN: Some mocked out stuff + mocked_display = MagicMock() + vlc_player = VlcPlayer(None) + + # WHEN: reset() is called + vlc_player.reset(mocked_display) + + # THEN: The media should be stopped and invisible + mocked_display.vlc_media_player.stop.assert_called_with() + mocked_display.vlc_widget.setVisible.assert_called_with(False) + assert MediaState.Off == vlc_player.get_live_state() + + +def test_set_visible_has_own_widget(): + """ + Test the set_visible() method when the player has its own widget + """ + # GIVEN: Some mocked out stuff + mocked_display = MagicMock() + vlc_player = VlcPlayer(None) + vlc_player.has_own_widget = True + + # WHEN: reset() is called + vlc_player.set_visible(mocked_display, True) + + # THEN: The media should be stopped and invsibile + mocked_display.vlc_widget.setVisible.assert_called_with(True) + + +@patch('openlp.core.ui.media.vlcplayer.get_vlc') +def test_update_ui(mocked_get_vlc): + """ + Test updating the UI + """ + # 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.end_time = 300 + mocked_controller.seek_slider.isSliderDown.return_value = False + mocked_display = MagicMock() + mocked_controller.vlc_media.get_state.return_value = 1 + mocked_controller.vlc_media_player.get_time.return_value = 400000 + 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_controller, mocked_display) + + # THEN: Certain methods should be called + mocked_stop.assert_called_with(mocked_controller) + assert 2 == mocked_stop.call_count + mocked_controller.vlc_media_player.get_time.assert_called_with() + mocked_set_visible.assert_called_with(mocked_controller, False) + mocked_controller.seek_slider.setSliderPosition.assert_called_with(400000) + expected_calls = [call(True), call(False)] + assert expected_calls == mocked_controller.seek_slider.blockSignals.call_args_list + + +@patch('openlp.core.ui.media.vlcplayer.get_vlc') +def test_update_ui_dvd(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 = ItemMediaInfo() + 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_controller.vlc_media.get_state.return_value = 1 + mocked_controller.vlc_media_player.get_time.return_value = 300 + mocked_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: + vlc_player.update_ui(mocked_controller, mocked_display) + + # THEN: Certain methods should be called + mocked_stop.assert_called_with(mocked_controller) + assert 1 == mocked_stop.call_count + mocked_controller.vlc_media_player.get_time.assert_called_with() + mocked_controller.seek_slider.setSliderPosition.assert_called_with(200) + expected_calls = [call(True), call(False)] + assert expected_calls == mocked_controller.seek_slider.blockSignals.call_args_list diff --git a/tests/functional/openlp_plugins/bibles/test_mediaitem.py b/tests/functional/openlp_plugins/bibles/test_mediaitem.py index b6e7eca64..a81534e05 100755 --- a/tests/functional/openlp_plugins/bibles/test_mediaitem.py +++ b/tests/functional/openlp_plugins/bibles/test_mediaitem.py @@ -738,14 +738,14 @@ class TestMediaItem(TestCase, TestMixin): Test on_style_combo_box_index_changed """ # GIVEN: An instance of :class:`MediaManagerItem` a mocked media_item.settings - self.media_item.settings = MagicMock() + self.media_item.settings_tab = MagicMock() # WHEN: Calling on_style_combo_box_index_changed self.media_item.on_style_combo_box_index_changed(2) # THEN: The layout_style setting should have been set - assert self.media_item.settings.layout_style == 2 - self.media_item.settings.layout_style_combo_box.setCurrentIndex.assert_called_once_with(2) + assert self.media_item.settings_tab.layout_style == 2 + self.media_item.settings_tab.layout_style_combo_box.setCurrentIndex.assert_called_once_with(2) self.mocked_settings_instance.setValue.assert_called_once_with('bibles/verse layout style', 2) def test_on_version_combo_box_index_changed_no_bible(self):