openlp/tests/openlp_core/ui/test_mainwindow.py

583 lines
24 KiB
Python
Raw Normal View History

# -*- coding: utf-8 -*-
2019-04-13 13:00:22 +00:00
##########################################################################
# OpenLP - Open Source Lyrics Projection #
# ---------------------------------------------------------------------- #
2022-02-01 10:10:57 +00:00
# Copyright (c) 2008-2022 OpenLP Developers #
2019-04-13 13:00:22 +00:00
# ---------------------------------------------------------------------- #
# 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
import pytest
2018-01-13 07:24:20 +00:00
from pathlib import Path
from unittest.mock import MagicMock, patch
2021-04-03 15:56:47 +00:00
from shutil import rmtree
from tempfile import mkdtemp
2021-04-15 17:25:59 +00:00
from PyQt5 import QtCore, QtWidgets, QtGui
2021-09-02 20:43:42 +00:00
from openlp.core.common import is_macosx
2017-10-07 07:05:07 +00:00
from openlp.core.common.i18n import UiStrings
from openlp.core.common.registry import Registry
2017-10-23 22:09:57 +00:00
from openlp.core.display.screens import ScreenList
2021-04-15 17:25:59 +00:00
from openlp.core.lib.plugin import PluginStatus
from openlp.core.state import State
from openlp.core.ui.mainwindow import MainWindow
from tests.utils.constants import TEST_RESOURCES_PATH, RESOURCE_PATH
def _create_mock_action(parent, name, **kwargs):
2017-10-23 22:09:57 +00:00
"""
Create a fake action with some "real" attributes
2017-10-23 22:09:57 +00:00
"""
action = QtWidgets.QAction(parent)
action.setObjectName(name)
if kwargs.get('triggers'):
action.triggered.connect(kwargs.pop('triggers'))
return action
@pytest.fixture()
def main_window(state, settings, mocked_qapp):
app = Registry().get('application')
app.set_busy_cursor = MagicMock()
app.set_normal_cursor = MagicMock()
app.process_events = MagicMock()
app.args = []
Registry().set_flag('no_web_server', True)
add_toolbar_action_patcher = patch('openlp.core.ui.mainwindow.create_action')
mocked_add_toolbar_action = add_toolbar_action_patcher.start()
mocked_add_toolbar_action.side_effect = _create_mock_action
renderer_patcher = patch('openlp.core.display.render.Renderer')
renderer_patcher.start()
mocked_screen = MagicMock()
mocked_screen.geometry.return_value = QtCore.QRect(0, 0, 1024, 768)
mocked_qapp.screens = MagicMock()
mocked_qapp.screens.return_value = [mocked_screen]
mocked_qapp.primaryScreen = MagicMock()
mocked_qapp.primaryScreen.return_value = mocked_screen
ScreenList.create(mocked_qapp)
mainwindow = MainWindow()
yield mainwindow
del mainwindow
renderer_patcher.stop()
add_toolbar_action_patcher.stop()
2021-04-15 17:25:59 +00:00
@pytest.fixture()
def main_window_reduced(settings, state):
"""
Create the UI
"""
Registry().set_flag('no_web_server', True)
mocked_plugin = MagicMock()
mocked_plugin.status = PluginStatus.Active
mocked_plugin.icon = QtGui.QIcon()
Registry().register('mock_plugin', mocked_plugin)
State().add_service("mock", 1, is_plugin=True, status=PluginStatus.Active)
# Mock classes and methods used by mainwindow.
with patch('openlp.core.ui.mainwindow.SettingsForm'), \
patch('openlp.core.ui.mainwindow.OpenLPDockWidget'), \
patch('openlp.core.ui.mainwindow.QtWidgets.QToolBox'), \
patch('openlp.core.ui.mainwindow.QtWidgets.QMainWindow.addDockWidget'), \
patch('openlp.core.ui.mainwindow.ServiceManager'), \
patch('openlp.core.ui.mainwindow.ThemeManager'), \
patch('openlp.core.ui.mainwindow.ProjectorManager'), \
patch('openlp.core.ui.mainwindow.HttpServer'), \
patch('openlp.core.ui.mainwindow.WebSocketServer'), \
patch('openlp.core.ui.mainwindow.start_zeroconf'), \
patch('openlp.core.ui.mainwindow.PluginForm'):
return MainWindow()
def test_cmd_line_file(main_window):
"""
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(main_window.service_manager, 'load_file') as mocked_load_file:
main_window.open_cmd_line_files([service])
# THEN the service from the arguments is loaded
mocked_load_file.assert_called_with(Path(service))
def test_cmd_line_file_encoded(main_window):
"""
Test that passing a service file from the command line loads the service where extra encoded quotes are added
"""
# GIVEN a service as an argument to openlp
service_base = os.path.join(TEST_RESOURCES_PATH, 'service', 'test.osz')
service = f'&quot;{service_base}&quot;'
# WHEN the argument is processed
with patch.object(main_window.service_manager, 'load_file') as mocked_load_file:
main_window.open_cmd_line_files([service])
# THEN the service from the arguments is loaded
mocked_load_file.assert_called_with(Path(service_base))
2022-02-04 15:40:12 +00:00
def test_cmd_line_arg_no_service(main_window):
"""
2022-02-04 17:01:51 +00:00
Test that passing no service file does nothing.
"""
2022-02-04 17:01:51 +00:00
# GIVEN a command line argument for openlp
2022-02-04 15:40:12 +00:00
args = ['--disable-web-security']
# WHEN the argument is processed
with patch.object(main_window.service_manager, 'load_file') as mocked_load_file:
main_window.open_cmd_line_files(args)
# THEN the file should not be opened
assert mocked_load_file.called is False, 'load_file should not have been called'
2022-02-04 17:01:51 +00:00
def test_cmd_line_arg_not_service_file(main_window):
"""
2022-02-04 17:01:51 +00:00
Test that passing a file that is not a service does nothing.
"""
# GIVEN a non service file as an argument to openlp
2022-02-04 17:01:51 +00:00
args = ['run_openlp.py']
# WHEN the argument is processed
with patch.object(main_window.service_manager, 'load_file') as mocked_load_file:
main_window.open_cmd_line_files(args)
# THEN the file should not be opened
assert mocked_load_file.called is False, 'load_file should not have been called'
def test_cmd_line_arg_service_file_does_not_exist(main_window):
"""
Test that passing a file that does not exist does nothing.
"""
# GIVEN a service file that does not exist
args = ['Service 2022-02-06.osz']
# WHEN the argument is processed
with patch.object(main_window.service_manager, 'load_file') as mocked_load_file:
main_window.open_cmd_line_files(args)
# THEN the file should not be opened
assert mocked_load_file.called is False, 'load_file should not have been called'
def test_cmd_line_arg_other_args(main_window):
"""
Test that passing a service file with other command line arguments still opens the file
"""
# GIVEN a valid existing service file and a command line argument
service_file = os.path.join(TEST_RESOURCES_PATH, 'service', 'test.osz')
args = ['--disable-web-security', service_file]
# WHEN the argument is processed
with patch.object(main_window.service_manager, 'load_file') as mocked_load_file:
main_window.open_cmd_line_files(args)
# THEN the file should not be opened
assert mocked_load_file.called is True, 'load_file should have been called'
mocked_load_file.assert_called_with(Path(service_file))
@patch('openlp.core.ui.mainwindow.Path')
def test_cmd_line_filename_with_spaces(MockPath, main_window):
"""
2022-02-04 17:01:51 +00:00
Test that a service file with spaces that split across arguments loads the file properly
"""
# GIVEN a set of arguments with a file separated by spaces
mocked_path_is_file = MagicMock(**{'is_file.return_value': True, 'suffix': '.osz'})
MockPath.return_value.resolve.side_effect = [FileNotFoundError, FileNotFoundError,
FileNotFoundError, mocked_path_is_file]
args = ['Service', '2022-02-06.osz']
2022-02-04 15:40:12 +00:00
# WHEN the argument is processed
with patch.object(main_window.service_manager, 'load_file') as mocked_load_file:
main_window.open_cmd_line_files(args)
# THEN the file should be looked for
assert MockPath.return_value.resolve.call_count == 4
mocked_load_file.assert_called_with(mocked_path_is_file)
@patch('openlp.core.ui.mainwindow.Path')
def test_cmd_line_filename_with_spaces_and_security(MockPath, main_window):
"""
2022-02-04 17:01:51 +00:00
Test that passing a service file with spaces and a command line argument loads properly
2022-02-04 15:40:12 +00:00
"""
# GIVEN a set of arguments with a file separated by spaces
mocked_path_is_file = MagicMock(**{'is_file.return_value': True, 'suffix': '.osz'})
MockPath.return_value.resolve.side_effect = [FileNotFoundError, FileNotFoundError,
FileNotFoundError, mocked_path_is_file]
args = ['--disable-web-security', 'Service', '2022-02-06.osz']
# WHEN the argument is processed
with patch.object(main_window.service_manager, 'load_file') as mocked_load_file:
main_window.open_cmd_line_files(args)
# THEN the file should be looked for
assert MockPath.return_value.resolve.call_count == 4
mocked_load_file.assert_called_with(mocked_path_is_file)
def test_main_window_title(main_window):
"""
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 should be the same as the OpenLP string in the UiStrings class
assert 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_modified(main_window):
"""
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
main_window.set_service_modified(True, 'test.osz')
# THEN the main window's title should be set to the
assert 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(main_window):
"""
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
main_window.set_service_modified(False, 'test.osz')
# THEN the main window's title should be set to the
assert 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"'
2021-08-19 16:23:56 +00:00
def test_load_settings_position_valid(main_window, settings):
"""
Test that the position of the main window is restored when it's valid
"""
# GIVEN a newly opened OpenLP instance, mocked screens and settings for a valid window position
# mock out some other calls in load_settings()
main_window.control_splitter = MagicMock()
main_window._live_controller = MagicMock()
main_window._preview_controller = MagicMock()
# set up a window position and geometry to use in the settings
main_window.move(QtCore.QPoint(10, 10))
main_window.resize(1000, 500)
# need to call show() to ensure the geometry works as expected
# unfortunately this seems to work on Windows only, not on linux
main_window.show()
main_window.hide()
# store the values in the settings
settings.setValue('user interface/main window position', main_window.pos())
settings.setValue('user interface/main window geometry', main_window.saveGeometry())
settings.setValue('user interface/main window state', main_window.saveState())
# change the position and size - then we can test if load_settings() sets it back correctly
main_window.move(QtCore.QPoint(20, 20))
main_window.resize(500, 300)
# WHEN the settings are loaded
main_window.load_settings()
# THEN the main window's position and geometry should be set to the saved setting
# on linux the tests works for the x position only
assert main_window.pos().x() == 10
2021-09-02 20:43:42 +00:00
@pytest.mark.skipif(is_macosx(), reason='Test does not work on macOS')
2021-08-19 16:23:56 +00:00
def test_load_settings_position_invalid(main_window, settings):
"""
Test that the position of the main window is not restored when it's invalid, but rather set to (0, 0)
"""
# GIVEN a newly opened OpenLP instance, mocked screens and settings for a valid window position
# mock out some other calls in load_settings()
main_window.control_splitter = MagicMock()
main_window._live_controller = MagicMock()
main_window._preview_controller = MagicMock()
# set up a window position outside the parameters of the main_window fixture
# this can represent a monitor positioned above the primary display, but which has been unplugged
main_window.move(QtCore.QPoint(-100, -800))
main_window.resize(1000, 500)
# need to call show() to ensure the geometry works as expected (works on Windows, but not linux)
main_window.show()
main_window.hide()
# store the values in the settings
settings.setValue('user interface/main window position', main_window.pos())
settings.setValue('user interface/main window geometry', main_window.saveGeometry())
settings.setValue('user interface/main window state', main_window.saveState())
# change the position and size
main_window.move(QtCore.QPoint(20, 20))
main_window.resize(500, 300)
# WHEN the settings are loaded
main_window.load_settings()
# THEN the main window's position should be (0, 0)
assert main_window.pos().x() == 0
def test_mainwindow_configuration(main_window):
"""
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 = ['settings', 'settings_thread', 'application', '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',
2022-01-16 13:15:09 +00:00
'config_screen_changed', 'theme_change_global']
assert list(Registry().service_list.keys()) == expected_service_list, \
'The service list should have been {}'.format(Registry().service_list.keys())
assert list(Registry().functions_list.keys()) == expected_functions_list, \
'The function list should have been {}'.format(Registry().functions_list.keys())
assert 'application' in Registry().service_list, 'The application should have been registered.'
assert 'main_window' in Registry().service_list, 'The main_window should have been registered.'
assert 'settings' in Registry().service_list, 'The settings should have been registered.'
def test_projector_manager_hidden_on_startup(main_window):
"""
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 main_window.projector_manager_dock.isVisible() is False
def test_on_search_shortcut_triggered_shows_media_manager(main_window):
"""
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(main_window, 'media_manager_dock') as mocked_media_manager_dock, \
patch.object(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
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(main_window):
"""
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(main_window, 'media_manager_dock') as mocked_media_manager_dock, \
patch.object(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
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(mocked_warning, MockWizard, main_window):
"""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
main_window.settings.setValue('projector/show after wizard', True)
with patch.object(main_window, 'projector_manager_dock') as mocked_dock, \
patch.object(Registry(), 'execute'), patch.object(main_window, 'theme_manager_contents'):
# WHEN: on_first_time_wizard_clicked is called
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(mocked_warning, MockWizard, main_window):
"""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
main_window.settings.setValue('projector/show after wizard', False)
# WHEN: on_first_time_wizard_clicked is called
with patch.object(main_window, 'projector_manager_dock') as mocked_dock, \
patch.object(Registry(), 'execute'), patch.object(main_window, 'theme_manager_contents'):
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(main_window):
"""
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(main_window, 'load_progress_bar', **{'value.return_value': 0}) as mocked_progress_bar:
# WHEN: Calling increment_progress_bar without the `increment` arg
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(main_window):
"""
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(main_window, 'load_progress_bar', **{'value.return_value': 0}) as mocked_progress_bar:
# WHEN: Calling increment_progress_bar with `increment` set to 10
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(main_window):
"""
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 = 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 Registry().get('application').args[0] == file_path, "The path should be in args."
@patch('openlp.core.ui.mainwindow.is_macosx')
def test_application_activate_event(mocked_is_macosx, main_window):
"""
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)
main_window.showMinimized()
# WHEN: The icon in the dock is clicked
result = main_window.eventFilter(MagicMock(), event)
# THEN:
assert result is True, "The method should have returned True."
assert main_window.isMinimized() is False
2021-04-03 15:56:47 +00:00
@patch('openlp.core.app.QtWidgets.QMessageBox.critical')
@patch('openlp.core.common.applocation.AppLocation.get_data_path')
@patch('openlp.core.common.applocation.AppLocation.get_directory')
def test_change_data_directory(mocked_get_directory, mocked_get_data_path, mocked_critical_box, main_window):
"""
Test that changing the data directory works if the folder already exists
"""
# GIVEN: an existing old and new data directory.
temp_folder = Path(mkdtemp())
mocked_get_data_path.return_value = temp_folder
main_window.copy_data = True
temp_new_data_folder = Path(mkdtemp())
main_window.new_data_path = temp_new_data_folder
# WHEN: running change_data_directory
result = main_window.change_data_directory()
# THEN: No error shouuld have occured
assert result is not False
mocked_critical_box.assert_not_called()
# Clean up
rmtree(temp_folder)
rmtree(temp_new_data_folder)
2021-04-15 17:25:59 +00:00
def test_restore_current_media_manager_item(main_window_reduced):
"""
Regression test for bug #1152509.
"""
# save current plugin: True; current media plugin: 2
main_window_reduced.settings.setValue('advanced/save current plugin', True)
main_window_reduced.settings.setValue('advanced/current media plugin', 2)
# WHEN: Call the restore method.
main_window_reduced.restore_current_media_manager_item()
# THEN: The current widget should have been set.
main_window_reduced.media_tool_box.setCurrentIndex.assert_called_with(2)
def test_projector_manager_dock_locked(main_window_reduced):
"""
Projector Manager enable UI options - bug #1390702
"""
# GIVEN: A mocked projector manager dock item:
projector_dock = main_window_reduced.projector_manager_dock
# WHEN: main_window.lock_panel action is triggered
main_window_reduced.lock_panel.triggered.emit(True)
# THEN: Projector manager dock should have been called with disable UI features
projector_dock.setFeatures.assert_called_with(0)
def test_projector_manager_dock_unlocked(main_window_reduced):
"""
Projector Manager disable UI options - bug #1390702
"""
# GIVEN: A mocked projector manager dock item:
projector_dock = main_window_reduced.projector_manager_dock
# WHEN: main_window.lock_panel action is triggered
main_window_reduced.lock_panel.triggered.emit(False)
# THEN: Projector manager dock should have been called with enable UI features
projector_dock.setFeatures.assert_called_with(7)