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):