forked from openlp/openlp
315 lines
15 KiB
Python
315 lines
15 KiB
Python
# -*- coding: utf-8 -*-
|
|
|
|
##########################################################################
|
|
# OpenLP - Open Source Lyrics Projection #
|
|
# ---------------------------------------------------------------------- #
|
|
# Copyright (c) 2008-2020 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 <https://www.gnu.org/licenses/>. #
|
|
##########################################################################
|
|
"""
|
|
Package to test openlp.core.ui.mainwindow package.
|
|
"""
|
|
import os
|
|
from pathlib import Path
|
|
from unittest import TestCase
|
|
from unittest.mock import MagicMock, patch
|
|
|
|
from PyQt5 import QtCore, QtWidgets
|
|
|
|
from openlp.core.state import State
|
|
from openlp.core.common.i18n import UiStrings
|
|
from openlp.core.common.registry import Registry
|
|
from openlp.core.common.settings import Settings
|
|
from openlp.core.display.screens import ScreenList
|
|
from openlp.core.ui.mainwindow import MainWindow
|
|
from tests.helpers.testmixin import TestMixin
|
|
from tests.utils.constants import TEST_RESOURCES_PATH, RESOURCE_PATH
|
|
|
|
|
|
class TestMainWindow(TestCase, TestMixin):
|
|
"""
|
|
Test the main window
|
|
"""
|
|
def _create_mock_action(self, parent, name, **kwargs):
|
|
"""
|
|
Create a fake action with some "real" attributes
|
|
"""
|
|
action = QtWidgets.QAction(parent)
|
|
action.setObjectName(name)
|
|
if kwargs.get('triggers'):
|
|
action.triggered.connect(kwargs.pop('triggers'))
|
|
return action
|
|
|
|
def setUp(self):
|
|
"""
|
|
Set up the objects we need for all of the tests
|
|
"""
|
|
Registry.create()
|
|
self.registry = Registry()
|
|
self.setup_application()
|
|
# Mock cursor busy/normal methods.
|
|
self.app.set_busy_cursor = MagicMock()
|
|
self.app.set_normal_cursor = MagicMock()
|
|
self.app.process_events = MagicMock()
|
|
self.app.args = []
|
|
Registry().register('application', self.app)
|
|
Registry().register('settings', Settings())
|
|
Registry().set_flag('no_web_server', True)
|
|
self.add_toolbar_action_patcher = patch('openlp.core.ui.mainwindow.create_action')
|
|
self.mocked_add_toolbar_action = self.add_toolbar_action_patcher.start()
|
|
self.mocked_add_toolbar_action.side_effect = self._create_mock_action
|
|
self.renderer_patcher = patch('openlp.core.display.render.Renderer')
|
|
self.mocked_renderer = self.renderer_patcher.start()
|
|
mocked_desktop = MagicMock()
|
|
mocked_desktop.screenCount.return_value = 1
|
|
mocked_desktop.screenGeometry.return_value = QtCore.QRect(0, 0, 1024, 768)
|
|
mocked_desktop.primaryScreen.return_value = 1
|
|
ScreenList.create(mocked_desktop)
|
|
State().load_settings()
|
|
self.main_window = MainWindow()
|
|
|
|
def tearDown(self):
|
|
"""
|
|
Delete all the C++ objects and stop all the patchers
|
|
"""
|
|
del self.main_window
|
|
self.renderer_patcher.stop()
|
|
self.add_toolbar_action_patcher.stop()
|
|
|
|
def test_cmd_line_file(self):
|
|
"""
|
|
Test that passing a service file from the command line loads the service.
|
|
"""
|
|
# GIVEN a service as an argument to openlp
|
|
service = os.path.join(TEST_RESOURCES_PATH, 'service', 'test.osz')
|
|
|
|
# WHEN the argument is processed
|
|
with patch.object(self.main_window.service_manager, 'load_file') as mocked_load_file:
|
|
self.main_window.open_cmd_line_files([service])
|
|
|
|
# THEN the service from the arguments is loaded
|
|
mocked_load_file.assert_called_with(Path(service))
|
|
|
|
@patch('openlp.core.ui.servicemanager.ServiceManager.load_file')
|
|
def test_cmd_line_arg(self, mocked_load_file):
|
|
"""
|
|
Test that passing a non service file does nothing.
|
|
"""
|
|
# GIVEN a non service file as an argument to openlp
|
|
service = 'run_openlp.py'
|
|
|
|
# WHEN the argument is processed
|
|
self.main_window.open_cmd_line_files(service)
|
|
|
|
# THEN the file should not be opened
|
|
assert mocked_load_file.called is False, 'load_file should not have been called'
|
|
|
|
def test_main_window_title(self):
|
|
"""
|
|
Test that running a new instance of OpenLP set the window title correctly
|
|
"""
|
|
# GIVEN a newly opened OpenLP instance
|
|
|
|
# WHEN no changes are made to the service
|
|
|
|
# THEN the main window's title shoud be the same as the OpenLP string in the UiStrings class
|
|
assert self.main_window.windowTitle() == UiStrings().OpenLP, \
|
|
'The main window\'s title should be the same as the OpenLP string in UiStrings class'
|
|
|
|
def test_set_service_modifed(self):
|
|
"""
|
|
Test that when setting the service's title the main window's title is set correctly
|
|
"""
|
|
# GIVEN a newly opened OpenLP instance
|
|
|
|
# WHEN set_service_modified is called with with the modified flag set true and a file name
|
|
self.main_window.set_service_modified(True, 'test.osz')
|
|
|
|
# THEN the main window's title should be set to the
|
|
assert self.main_window.windowTitle(), '%s - %s*' % (UiStrings().OpenLP, 'test.osz') == \
|
|
'The main window\'s title should be set to "<the contents of UiStrings().OpenLP> - test.osz*"'
|
|
|
|
def test_set_service_unmodified(self):
|
|
"""
|
|
Test that when setting the service's title the main window's title is set correctly
|
|
"""
|
|
# GIVEN a newly opened OpenLP instance
|
|
|
|
# WHEN set_service_modified is called with with the modified flag set False and a file name
|
|
self.main_window.set_service_modified(False, 'test.osz')
|
|
|
|
# THEN the main window's title should be set to the
|
|
assert self.main_window.windowTitle(), '%s - %s' % (UiStrings().OpenLP, 'test.osz') == \
|
|
'The main window\'s title should be set to "<the contents of UiStrings().OpenLP> - test.osz"'
|
|
|
|
def test_mainwindow_configuration(self):
|
|
"""
|
|
Check that the Main Window initialises the Registry Correctly
|
|
"""
|
|
# GIVEN: A built main window
|
|
|
|
# WHEN: you check the started functions
|
|
|
|
# THEN: the following registry functions should have been registered
|
|
expected_service_list = ['application', 'settings', 'main_window', 'http_server', 'authentication_token',
|
|
'settings_form', 'service_manager', 'theme_manager', 'projector_manager']
|
|
expected_functions_list = ['bootstrap_initialise', 'bootstrap_post_set_up', 'bootstrap_completion',
|
|
'theme_update_global', 'config_screen_changed']
|
|
assert list(self.registry.service_list.keys()) == expected_service_list, \
|
|
'The service list should have been {}'.format(self.registry.service_list.keys())
|
|
assert list(self.registry.functions_list.keys()) == expected_functions_list, \
|
|
'The function list should have been {}'.format(self.registry.functions_list.keys())
|
|
assert 'application' in self.registry.service_list, 'The application should have been registered.'
|
|
assert 'main_window' in self.registry.service_list, 'The main_window should have been registered.'
|
|
|
|
def test_projector_manager_hidden_on_startup(self):
|
|
"""
|
|
Test that the projector manager is hidden on startup
|
|
"""
|
|
# GIVEN: A built main window
|
|
# WHEN: OpenLP is started
|
|
# THEN: The projector manager should be hidden
|
|
assert self.main_window.projector_manager_dock.isVisible() is False
|
|
|
|
def test_on_search_shortcut_triggered_shows_media_manager(self):
|
|
"""
|
|
Test that the media manager is made visible when the search shortcut is triggered
|
|
"""
|
|
# GIVEN: A build main window set up for testing
|
|
with patch.object(self.main_window, 'media_manager_dock') as mocked_media_manager_dock, \
|
|
patch.object(self.main_window, 'media_tool_box') as mocked_media_tool_box:
|
|
mocked_media_manager_dock.isVisible.return_value = False
|
|
mocked_media_tool_box.currentWidget.return_value = None
|
|
|
|
# WHEN: The search shortcut is triggered
|
|
self.main_window.on_search_shortcut_triggered()
|
|
|
|
# THEN: The media manager dock is made visible
|
|
mocked_media_manager_dock.setVisible.assert_called_with(True)
|
|
|
|
def test_on_search_shortcut_triggered_focuses_widget(self):
|
|
"""
|
|
Test that the focus is set on the widget when the search shortcut is triggered
|
|
"""
|
|
# GIVEN: A build main window set up for testing
|
|
with patch.object(self.main_window, 'media_manager_dock') as mocked_media_manager_dock, \
|
|
patch.object(self.main_window, 'media_tool_box') as mocked_media_tool_box:
|
|
mocked_media_manager_dock.isVisible.return_value = True
|
|
mocked_widget = MagicMock()
|
|
mocked_media_tool_box.currentWidget.return_value = mocked_widget
|
|
|
|
# WHEN: The search shortcut is triggered
|
|
self.main_window.on_search_shortcut_triggered()
|
|
|
|
# THEN: The media manager dock is made visible
|
|
assert 0 == mocked_media_manager_dock.setVisible.call_count
|
|
mocked_widget.on_focus.assert_called_with()
|
|
|
|
@patch('openlp.core.ui.mainwindow.FirstTimeForm')
|
|
@patch('openlp.core.ui.mainwindow.QtWidgets.QMessageBox.warning')
|
|
def test_on_first_time_wizard_clicked_show_projectors_after(self, mocked_warning, MockWizard):
|
|
"""Test that the projector manager is shown after the FTW is run"""
|
|
# GIVEN: Main_window, patched things, patched "Yes" as confirmation to re-run wizard, settings to True.
|
|
mocked_warning.return_value = QtWidgets.QMessageBox.Yes
|
|
MockWizard.return_value.was_cancelled = False
|
|
self.main_window.settings.setValue('projector/show after wizard', True)
|
|
|
|
with patch.object(self.main_window, 'projector_manager_dock') as mocked_dock, \
|
|
patch.object(self.registry, 'execute'), patch.object(self.main_window, 'theme_manager_contents'):
|
|
# WHEN: on_first_time_wizard_clicked is called
|
|
self.main_window.on_first_time_wizard_clicked()
|
|
|
|
# THEN: projector_manager_dock.setVisible should had been called once
|
|
mocked_dock.setVisible.assert_called_once_with(True)
|
|
|
|
@patch('openlp.core.ui.mainwindow.FirstTimeForm')
|
|
@patch('openlp.core.ui.mainwindow.QtWidgets.QMessageBox.warning')
|
|
def test_on_first_time_wizard_clicked_hide_projectors_after(self, mocked_warning, MockWizard):
|
|
"""Test that the projector manager is hidden after the FTW is run"""
|
|
# GIVEN: Main_window, patched things, patched "Yes" as confirmation to re-run wizard, settings to False.
|
|
mocked_warning.return_value = QtWidgets.QMessageBox.Yes
|
|
MockWizard.return_value.was_cancelled = False
|
|
self.main_window.settings.setValue('projector/show after wizard', False)
|
|
|
|
# WHEN: on_first_time_wizard_clicked is called
|
|
with patch.object(self.main_window, 'projector_manager_dock') as mocked_dock, \
|
|
patch.object(self.registry, 'execute'), patch.object(self.main_window, 'theme_manager_contents'):
|
|
self.main_window.on_first_time_wizard_clicked()
|
|
|
|
# THEN: projector_manager_dock.setVisible should had been called once
|
|
mocked_dock.setVisible.assert_called_once_with(False)
|
|
|
|
def test_increment_progress_bar_default_increment(self):
|
|
"""
|
|
Test that increment_progress_bar increments the progress bar by 1 when called without the `increment` arg.
|
|
"""
|
|
# GIVEN: A mocked progress bar
|
|
with patch.object(self.main_window, 'load_progress_bar', **{'value.return_value': 0}) as mocked_progress_bar:
|
|
|
|
# WHEN: Calling increment_progress_bar without the `increment` arg
|
|
self.main_window.increment_progress_bar()
|
|
|
|
# THEN: The progress bar value should have been incremented by 1
|
|
mocked_progress_bar.setValue.assert_called_once_with(1)
|
|
|
|
def test_increment_progress_bar_custom_increment(self):
|
|
"""
|
|
Test that increment_progress_bar increments the progress bar by the `increment` arg when called with the
|
|
`increment` arg with a set value.
|
|
"""
|
|
# GIVEN: A mocked progress bar
|
|
with patch.object(self.main_window, 'load_progress_bar', **{'value.return_value': 0}) as mocked_progress_bar:
|
|
|
|
# WHEN: Calling increment_progress_bar with `increment` set to 10
|
|
self.main_window.increment_progress_bar(increment=10)
|
|
|
|
# THEN: The progress bar value should have been incremented by 10
|
|
mocked_progress_bar.setValue.assert_called_once_with(10)
|
|
|
|
def test_eventFilter(self):
|
|
"""
|
|
Test the reimplemented event method
|
|
"""
|
|
# GIVEN: A file path and a QEvent.
|
|
file_path = str(RESOURCE_PATH / 'church.jpg')
|
|
mocked_file_method = MagicMock(return_value=file_path)
|
|
event = QtCore.QEvent(QtCore.QEvent.FileOpen)
|
|
event.file = mocked_file_method
|
|
|
|
# WHEN: Call the vent method.
|
|
result = self.main_window.eventFilter(MagicMock(), event)
|
|
|
|
# THEN: The path should be inserted.
|
|
assert result is True, "The method should have returned True."
|
|
mocked_file_method.assert_called_once_with()
|
|
assert self.app.args[0] == file_path, "The path should be in args."
|
|
|
|
@patch('openlp.core.ui.mainwindow.is_macosx')
|
|
def test_application_activate_event(self, mocked_is_macosx):
|
|
"""
|
|
Test that clicking on the dock icon on Mac OS X restores the main window if it is minimized
|
|
"""
|
|
# GIVEN: Mac OS X and an ApplicationActivate event
|
|
mocked_is_macosx.return_value = True
|
|
event = QtCore.QEvent(QtCore.QEvent.ApplicationActivate)
|
|
self.main_window.showMinimized()
|
|
|
|
# WHEN: The icon in the dock is clicked
|
|
result = self.main_window.eventFilter(MagicMock(), event)
|
|
|
|
# THEN:
|
|
assert result is True, "The method should have returned True."
|
|
assert self.main_window.isMinimized() is False
|