openlp/tests/functional/openlp_plugins/bibles/test_mediaitem.py
2017-06-03 23:34:19 +01:00

1469 lines
76 KiB
Python
Executable File

# -*- coding: utf-8 -*-
# vim: autoindent shiftwidth=4 expandtab textwidth=120 tabstop=4 softtabstop=4
###############################################################################
# OpenLP - Open Source Lyrics Projection #
# --------------------------------------------------------------------------- #
# Copyright (c) 2008-2017 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; version 2 of the License. #
# #
# 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, write to the Free Software Foundation, Inc., 59 #
# Temple Place, Suite 330, Boston, MA 02111-1307 USA #
###############################################################################
"""
This module contains tests for the lib submodule of the Presentations plugin.
"""
from unittest import TestCase
from unittest.mock import MagicMock, call, patch
from PyQt5 import QtCore, QtWidgets
from tests.helpers.testmixin import TestMixin
from openlp.core.common import Registry
from openlp.core.lib import MediaManagerItem
from openlp.plugins.bibles.lib.mediaitem import BibleMediaItem, BibleSearch, ResultsTab, SearchStatus, SearchTabs, \
get_reference_separators, VALID_TEXT_SEARCH
class TestBibleMediaItemModulefunctions(TestCase):
"""
Test the module functions in :mod:`openlp.plugins.bibles.lib.mediaitem`
"""
def test_valid_text_search(self):
"""
Test the compiled VALID_TEXT_SEARCH regex expression
"""
# GIVEN: Some test data and some expected results
test_data = [('a a a', None), ('a ab a', None), ('a abc a', ((2, 5),)), ('aa 123 aa', ((3, 6),))]
for data, expected_result in test_data:
# WHEN: Calling search on the compiled regex expression
result = VALID_TEXT_SEARCH.search(data)
# THEN: The expected result should be returned
if expected_result is None:
self.assertIsNone(result, expected_result)
else:
self.assertEqual(result.regs, expected_result)
def test_get_reference_separators(self):
"""
Test the module function get_reference_separators
"""
# GIVEN: A mocked get_reference_separator from the :mod:`openlp.plugins.bibles.lib` module
with patch('openlp.plugins.bibles.lib.mediaitem.get_reference_separator') as mocked_get_reference_separator:
# WHEN: Calling get_reference_separators
result = get_reference_separators()
# THEN: The result should contain the 'verse', 'range', 'list' keys and get_reference_separator should have
# been called with the expected values.
self.assertTrue(all(key in result for key in ('verse', 'range', 'list')))
mocked_get_reference_separator.assert_has_calls(
[call('sep_v_display'), call('sep_r_display'), call('sep_l_display')])
def test_bible_search_enum(self):
"""
Test that the :class:`BibleSearch` class contains the expected enumerations
"""
# GIVEN: The BibleSearch class
# WHEN: Testing its attributes
# THEN: The BibleSearch class should have the following enumrations
self.assertTrue(hasattr(BibleSearch, 'Combined'))
self.assertTrue(hasattr(BibleSearch, 'Reference'))
self.assertTrue(hasattr(BibleSearch, 'Text'))
def test_bible_media_item_subclass(self):
"""
Test that the :class:`BibleMediaItem` class is a subclass of the :class:`MediaManagerItem` class
"""
# GIVEN: The :class:`BibleMediaItem`
# WHEN: Checking if it is a subclass of MediaManagerItem
# THEN: BibleMediaItem should be a subclass of MediaManagerItem
self.assertTrue(issubclass(BibleMediaItem, MediaManagerItem))
def test_bible_media_item_signals(self):
"""
Test that the :class:`BibleMediaItem` class has the expected signals
"""
# GIVEN: The :class:`BibleMediaItem`
# THEN: The :class:`BibleMediaItem` should contain the following pyqtSignal's
self.assertTrue(hasattr(BibleMediaItem, 'bibles_go_live'))
self.assertTrue(hasattr(BibleMediaItem, 'bibles_add_to_service'))
self.assertTrue(isinstance(BibleMediaItem.bibles_go_live, QtCore.pyqtSignal))
self.assertTrue(isinstance(BibleMediaItem.bibles_add_to_service, QtCore.pyqtSignal))
class TestMediaItem(TestCase, TestMixin):
"""
Test the bible mediaitem methods.
"""
def setUp(self):
"""
Set up the components need for all tests.
"""
log_patcher = patch('openlp.plugins.bibles.lib.mediaitem.log')
self.addCleanup(log_patcher.stop)
self.mocked_log = log_patcher.start()
qtimer_patcher = patch('openlp.plugins.bibles.lib.mediaitem.QtCore.QTimer')
self.addCleanup(qtimer_patcher.stop)
self.mocked_qtimer = qtimer_patcher.start()
self.mocked_settings_instance = MagicMock()
self.mocked_settings_instance.value.side_effect = lambda key: self.setting_values[key]
settings_patcher = patch(
'openlp.plugins.bibles.lib.mediaitem.Settings', return_value=self.mocked_settings_instance)
self.addCleanup(settings_patcher.stop)
self.mocked_settings = settings_patcher.start()
Registry.create()
# self.setup_application()
self.mocked_application = MagicMock()
Registry().register('application', self.mocked_application)
self.mocked_main_window = MagicMock()
Registry().register('main_window', self.mocked_main_window)
self.mocked_plugin = MagicMock()
with patch('openlp.plugins.bibles.lib.mediaitem.build_icon'), \
patch('openlp.plugins.bibles.lib.mediaitem.MediaManagerItem._setup'), \
patch('openlp.plugins.bibles.lib.mediaitem.BibleMediaItem.setup_item'):
self.media_item = BibleMediaItem(None, self.mocked_plugin)
self.media_item.settings_section = 'bibles'
self.media_item.results_view_tab = MagicMock()
self.mocked_book_1 = MagicMock(**{'get_name.return_value': 'Book 1', 'book_reference_id': 1})
self.mocked_book_2 = MagicMock(**{'get_name.return_value': 'Book 2', 'book_reference_id': 2})
self.mocked_book_3 = MagicMock(**{'get_name.return_value': 'Book 3', 'book_reference_id': 3})
self.mocked_book_4 = MagicMock(**{'get_name.return_value': 'Book 4', 'book_reference_id': 4})
self.book_list_1 = [self.mocked_book_1, self.mocked_book_2, self.mocked_book_3]
self.book_list_2 = [self.mocked_book_2, self.mocked_book_3, self.mocked_book_4]
self.mocked_bible_1 = MagicMock(**{'get_books.return_value': self.book_list_1})
self.mocked_bible_1.name = 'Bible 1'
self.mocked_bible_2 = MagicMock(**{'get_books.return_value': self.book_list_2})
self.mocked_bible_2.name = 'Bible 2'
def test_media_item_instance(self):
"""
When creating an instance of C test that it is also an instance of
:class:`MediaManagerItem`
"""
# GIVEN: An instance of :class:`BibleMediaItem`
# WEHN: Checking its class
# THEN: It should be a subclass of :class:`MediaManagerItem`
self.assertTrue(isinstance(self.media_item, MediaManagerItem))
def test_steup_item(self):
"""
Test the setup_item method
"""
# Could have tested the connection of the custom signals, however they're class vairables, and I could not find
# a way to properly test them.
# GIVEN: A mocked Registry.register_function method and an instance of BibleMediaItem
with patch.object(Registry(), 'register_function') as mocked_register_function:
# WHEN: Calling setup_itme
self.media_item.setup_item()
# THEN: Registry.register_function method should have been called with the reload_bibles method
mocked_register_function.assert_called_once_with('bibles_load_list', self.media_item.reload_bibles)
def test_required_icons(self):
"""
Test that all the required icons are set properly.
"""
# GIVEN: An instance of :class:`MediaManagerItem`
# WHEN: required_icons is called
self.media_item.required_icons()
# THEN: The correct icons should be set
self.assertTrue(self.media_item.has_import_icon, 'Check that the icon is as True.')
self.assertFalse(self.media_item.has_new_icon, 'Check that the icon is called as False.')
self.assertTrue(self.media_item.has_edit_icon, 'Check that the icon is called as True.')
self.assertTrue(self.media_item.has_delete_icon, 'Check that the icon is called as True.')
self.assertFalse(self.media_item.add_to_service_item, 'Check that the icon is called as False')
# TODO: Test add_end_header_bar
# TODO: Test setupUi
def test_on_focus_search_tab_visible(self):
"""
Test the correct widget gets focus when the BibleMediaItem receives focus
"""
# GIVEN: An instance of :class:`MediaManagerItem` and mocked out tabs and primary widgets
self.media_item.search_tab = MagicMock(**{'isVisible.return_value': True})
self.media_item.search_edit = MagicMock()
self.media_item.select_tab = MagicMock(**{'isVisible.return_value': False})
self.media_item.select_book_combo_box = MagicMock()
self.media_item.options_tab = MagicMock(**{'isVisible.return_value': False})
self.media_item.version_combo_box = MagicMock()
# WHEN: Calling on_focus
self.media_item.on_focus()
# THEN: search_edit should now have focus and its text selected
self.media_item.search_edit.assert_has_calls([call.setFocus(), call.selectAll()])
self.media_item.select_book_combo_box.assert_not_called()
self.media_item.version_combo_box.setFocus.assert_not_called()
def test_on_focus_select_tab_visible(self):
"""
Test the correct widget gets focus when the BibleMediaItem receives focus
"""
# GIVEN: An instance of :class:`MediaManagerItem` and mocked out tabs and primary widgets
self.media_item.search_tab = MagicMock(**{'isVisible.return_value': False})
self.media_item.search_edit = MagicMock()
self.media_item.select_tab = MagicMock(**{'isVisible.return_value': True})
self.media_item.select_book_combo_box = MagicMock()
self.media_item.options_tab = MagicMock(**{'isVisible.return_value': False})
self.media_item.version_combo_box = MagicMock()
# WHEN: Calling on_focus
self.media_item.on_focus()
# THEN: select_book_combo_box should have focus
self.media_item.search_edit.setFocus.assert_not_called()
self.media_item.search_edit.selectAll.assert_not_called()
self.media_item.select_book_combo_box.setFocus.assert_called_once_with()
self.media_item.version_combo_box.setFocus.assert_not_called()
def test_on_focus_options_tab_visible(self):
"""
Test the correct widget gets focus when the BibleMediaItem receives focus
"""
# GIVEN: An instance of :class:`MediaManagerItem` and mocked out tabs and primary widgets
self.media_item.search_tab = MagicMock(**{'isVisible.return_value': False})
self.media_item.search_edit = MagicMock()
self.media_item.select_tab = MagicMock(**{'isVisible.return_value': False})
self.media_item.select_book_combo_box = MagicMock()
self.media_item.options_tab = MagicMock(**{'isVisible.return_value': True})
self.media_item.version_combo_box = MagicMock()
# WHEN: Calling on_focus
self.media_item.on_focus()
# THEN: version_combo_box have received focus
self.media_item.search_edit.setFocus.assert_not_called()
self.media_item.search_edit.selectAll.assert_not_called()
self.media_item.select_book_combo_box.setFocus.assert_not_called()
self.media_item.version_combo_box.setFocus.assert_called_once_with()
def test_config_update_show_second_bible(self):
"""
Test the config update method
"""
# GIVEN: An instance of :class:`MediaManagerItem` and mocked out settings class with known values
self.setting_values = {'bibles/second bibles': True}
self.media_item.general_bible_layout = MagicMock()
self.media_item.second_combo_box = MagicMock()
# WHEN: Calling config_update()
self.media_item.config_update()
# THEN: second_combo_box() should be set visible
self.media_item.second_combo_box.setVisible.assert_called_once_with(True)
def test_config_update_hide_second_bible(self):
"""
Test the config update method
"""
# GIVEN: An instance of :class:`MediaManagerItem` and mocked out settings class with known values
self.setting_values = {'bibles/second bibles': False}
self.media_item.general_bible_layout = MagicMock()
self.media_item.second_combo_box = MagicMock()
# WHEN: Calling config_update()
self.media_item.config_update()
# THEN: second_combo_box() should hidden
self.media_item.second_combo_box.setVisible.assert_called_once_with(False)
def test_initalise(self):
"""
Test the initalise method
"""
# GIVEN: An instance of :class:`MediaManagerItem` and mocked out settings class with known values
self.setting_values = {'bibles/reset to combined quick search': False}
with patch.object(self.media_item, 'populate_bible_combo_boxes'), \
patch.object(self.media_item, 'config_update'):
self.media_item.search_edit = MagicMock()
# WHEN: Calling initialise()
self.media_item.initialise()
# THEN: The search_edit search types should have been set.
self.assertTrue(self.media_item.search_edit.set_search_types.called)
self.assertFalse(self.media_item.search_edit.set_current_search_type.called)
def test_initalise_reset_search_type(self):
"""
Test the initalise method
"""
# GIVEN: An instance of :class:`MediaManagerItem` and mocked out settings class with known values
self.setting_values = {'bibles/reset to combined quick search': True}
with patch.object(self.media_item, 'populate_bible_combo_boxes'), \
patch.object(self.media_item, 'config_update'):
self.media_item.search_edit = MagicMock()
# WHEN: Calling initialise()
self.media_item.initialise()
# THEN: The search_edit search types should have been set and that the current search type should be set to
# 'Combined'
self.assertTrue(self.media_item.search_edit.set_search_types.called)
self.media_item.search_edit.set_current_search_type.assert_called_once_with(BibleSearch.Combined)
def test_populate_bible_combo_boxes(self):
"""
Test populate_bible_combo_boxes method
"""
# GIVEN: An instance of :class:`MediaManagerItem` and mocked out settings class with known values
bible_1 = MagicMock()
bible_2 = MagicMock()
bible_3 = MagicMock()
self.setting_values = {'bibles/primary bible': bible_2}
self.media_item.version_combo_box = MagicMock()
self.media_item.second_combo_box = MagicMock()
self.mocked_plugin.manager.get_bibles.return_value = \
{'Bible 2': bible_2, 'Bible 1': bible_1, 'Bible 3': bible_3}
with patch('openlp.plugins.bibles.lib.mediaitem.get_locale_key', side_effect=lambda x: x), \
patch('openlp.plugins.bibles.lib.mediaitem.find_and_set_in_combo_box'):
# WHEN: Calling populate_bible_combo_boxes
self.media_item.populate_bible_combo_boxes()
# THEN: The bible combo boxes should be filled with the bible names and data, in a sorted order.
self.media_item.version_combo_box.addItem.assert_has_calls(
[call('Bible 1', bible_1), call('Bible 2', bible_2), call('Bible 3', bible_3)])
self.media_item.second_combo_box.addItem.assert_has_calls(
[call('', None), call('Bible 1', bible_1), call('Bible 2', bible_2), call('Bible 3', bible_3)])
def test_reload_bibles(self):
"""
Test reload_bibles
"""
# GIVEN: An instance of :class:`MediaManagerItem` and mocked out settings class with known values
with patch.object(self.media_item, 'populate_bible_combo_boxes') as mocked_populate_bible_combo_boxes:
# WHEN: Calling reload_bibles()
self.media_item.reload_bibles()
# THEN: The manager reload_bibles method should have been called and the bible combo boxes updated
self.mocked_plugin.manager.reload_bibles.assert_called_once_with()
mocked_populate_bible_combo_boxes.assert_called_once_with()
def test_get_common_books_no_second_book(self):
"""
Test get_common_books when called with out a second bible
"""
# GIVEN: An instance of :class:`MediaManagerItem` and a mocked first bible
# WHEN: Calling get_common_books with only one bible
result = self.media_item.get_common_books(self.mocked_bible_1)
# THEN: The book of the bible should be returned
self.assertEqual(result, self.book_list_1)
def test_get_common_books_second_book(self):
"""
Test get_common_books when called with a second bible
"""
# GIVEN: An instance of :class:`MediaManagerItem` and two mocked bibles with differing books
# WHEN: Calling get_common_books with two bibles
result = self.media_item.get_common_books(self.mocked_bible_1, self.mocked_bible_2)
# THEN: Only the books contained in both bibles should be returned
self.assertEqual(result, [self.mocked_book_2, self.mocked_book_3])
def test_initialise_advanced_bible_no_bible(self):
"""
Test initialise_advanced_bible when there is no main bible
"""
# GIVEN: An instance of :class:`MediaManagerItem`
self.media_item.select_book_combo_box = MagicMock()
with patch.object(self.media_item, 'get_common_books') as mocked_get_common_books:
# WHEN: Calling initialise_advanced_bible() when there is no main bible
self.media_item.bible = None
result = self.media_item.initialise_advanced_bible()
# THEN: initialise_advanced_bible should return with put calling get_common_books
self.assertIsNone(result)
mocked_get_common_books.assert_not_called()
def test_initialise_advanced_bible_add_books_with_last_id_found(self):
"""
Test initialise_advanced_bible when the last_id argument is supplied and it is found in the list
"""
# GIVEN: An instance of :class:`MediaManagerItem` and a mocked_book_combo_box which simulates data being found
# in the list
self.media_item.select_book_combo_box = MagicMock(**{'findData.return_value': 2})
with patch.object(self.media_item, 'get_common_books', return_value=self.book_list_1), \
patch.object(self.media_item, 'on_advanced_book_combo_box'):
# WHEN: Calling initialise_advanced_bible() with the last_id argument set
self.media_item.bible = MagicMock()
self.media_item.initialise_advanced_bible(10)
# THEN: The books should be added to the combo box, and the chosen book should be reselected
self.media_item.select_book_combo_box.addItem.assert_has_calls(
[call('Book 1', 1), call('Book 2', 2), call('Book 3', 3)])
self.media_item.select_book_combo_box.setCurrentIndex.assert_called_once_with(2)
def test_initialise_advanced_bible_add_books_with_last_id_not_found(self):
"""
Test initialise_advanced_bible when the last_id argument is supplied and it is not found in the list
"""
# GIVEN: An instance of :class:`MediaManagerItem` and a mocked_book_combo_box which simulates data not being
# found in the list
self.media_item.select_book_combo_box = MagicMock(**{'findData.return_value': -1})
with patch.object(self.media_item, 'get_common_books', return_value=self.book_list_1), \
patch.object(self.media_item, 'on_advanced_book_combo_box'):
# WHEN: Calling initialise_advanced_bible() with the last_id argument set
self.media_item.bible = MagicMock()
self.media_item.initialise_advanced_bible(10)
# THEN: The books should be added to the combo box, and the first book should be selected
self.media_item.select_book_combo_box.addItem.assert_has_calls(
[call('Book 1', 1), call('Book 2', 2), call('Book 3', 3)])
self.media_item.select_book_combo_box.setCurrentIndex.assert_called_once_with(0)
def test_update_auto_completer_search_no_bible(self):
"""
Test update_auto_completer when there is no main bible selected and the search_edit type is
'BibleSearch.Reference'
"""
# GIVEN: An instance of :class:`MediaManagerItem` and a mocked search_edit
mocked_search_edit = MagicMock(**{'current_search_type.return_value': BibleSearch.Reference})
self.media_item.search_edit = mocked_search_edit
self.media_item.bible = None
with patch.object(self.media_item, 'get_common_books') as mocked_get_common_books, \
patch('openlp.plugins.bibles.lib.mediaitem.set_case_insensitive_completer') \
as mocked_set_case_insensitive_completer:
# WHEN: Calling update_auto_completer
self.media_item.update_auto_completer()
# THEN: get_common_books should not have been called. set_case_insensitive_completer should have been called
# with an empty list
mocked_get_common_books.assert_not_called()
mocked_set_case_insensitive_completer.assert_called_once_with([], mocked_search_edit)
def test_update_auto_completer_search_reference_type(self):
"""
Test update_auto_completer when a main bible is selected and the search_edit type is 'BibleSearch.Reference'
"""
# GIVEN: An instance of :class:`MediaManagerItem` and a mocked search_edit
mocked_search_edit = MagicMock(**{'current_search_type.return_value': BibleSearch.Reference})
self.media_item.search_edit = mocked_search_edit
self.media_item.bible = MagicMock()
with patch.object(self.media_item, 'get_common_books', return_value=self.book_list_1), \
patch('openlp.plugins.bibles.lib.mediaitem.get_locale_key', side_effect=lambda x: x), \
patch('openlp.plugins.bibles.lib.mediaitem.set_case_insensitive_completer') \
as mocked_set_case_insensitive_completer:
# WHEN: Calling update_auto_completer
self.media_item.update_auto_completer()
# THEN: set_case_insensitive_completer should have been called with the names of the books in order
mocked_set_case_insensitive_completer.assert_called_once_with(
['Book 1', 'Book 2', 'Book 3'], mocked_search_edit)
def test_update_auto_completer_search_combined_type(self):
"""
Test update_auto_completer when a main bible is selected and the search_edit type is 'BibleSearch.Combined'
"""
# GIVEN: An instance of :class:`MediaManagerItem` and a mocked search_edit
mocked_search_edit = MagicMock(**{'current_search_type.return_value': BibleSearch.Combined})
self.media_item.search_edit = mocked_search_edit
self.media_item.bible = MagicMock()
with patch.object(self.media_item, 'get_common_books', return_value=self.book_list_1), \
patch('openlp.plugins.bibles.lib.mediaitem.get_locale_key', side_effect=lambda x: x), \
patch('openlp.plugins.bibles.lib.mediaitem.set_case_insensitive_completer') \
as mocked_set_case_insensitive_completer:
# WHEN: Calling update_auto_completer
self.media_item.update_auto_completer()
# THEN: set_case_insensitive_completer should have been called with the names of the books in order
mocked_set_case_insensitive_completer.assert_called_once_with(
['Book 1', 'Book 2', 'Book 3'], mocked_search_edit)
def test_on_import_click_no_import_wizzard_attr(self):
"""
Test on_import_click when media_item does not have the `import_wizard` attribute. And the wizard was canceled.
"""
# GIVEN: An instance of :class:`MediaManagerItem` and a mocked BibleImportForm
mocked_bible_import_form_instance = MagicMock(**{'exec.return_value': False})
with patch('openlp.plugins.bibles.lib.mediaitem.BibleImportForm',
return_value=mocked_bible_import_form_instance) as mocked_bible_import_form, \
patch.object(self.media_item, 'reload_bibles') as mocked_reload_bibles:
# WHEN: Calling on_import_click
self.media_item.on_import_click()
# THEN: BibleImport wizard should have been instianted and reload_bibles should not have been called
self.assertTrue(mocked_bible_import_form.called)
self.assertFalse(mocked_reload_bibles.called)
def test_on_import_click_wizzard_not_canceled(self):
"""
Test on_import_click when the media item has the import_wizzard attr set and wizard completes sucessfully.
"""
# GIVEN: An instance of :class:`MediaManagerItem` and a mocked import_wizard
mocked_import_wizard = MagicMock(**{'exec.return_value': True})
self.media_item.import_wizard = mocked_import_wizard
with patch.object(self.media_item, 'reload_bibles') as mocked_reload_bibles:
# WHEN: Calling on_import_click
self.media_item.on_import_click()
# THEN: BibleImport wizard should have been instianted and reload_bibles should not have been called
self.assertFalse(mocked_import_wizard.called)
self.assertTrue(mocked_reload_bibles.called)
def test_on_edit_click_no_bible(self):
"""
Test on_edit_click when there is no main bible selected
"""
# GIVEN: An instance of :class:`MediaManagerItem`
with patch('openlp.plugins.bibles.lib.mediaitem.EditBibleForm') as mocked_edit_bible_form:
# WHEN: A main bible is not selected and on_edit_click is called
self.media_item.bible = None
self.media_item.on_edit_click()
# THEN: EditBibleForm should not have been instianted
self.assertFalse(mocked_edit_bible_form.called)
def test_on_edit_click_user_cancel_edit_form(self):
"""
Test on_edit_click when the user cancels the EditBibleForm
"""
# GIVEN: An instance of :class:`MediaManagerItem` and a mocked EditBibleForm which returns False when exec is
# called
self.media_item.bible = MagicMock()
mocked_edit_bible_form_instance = MagicMock(**{'exec.return_value': False})
with patch('openlp.plugins.bibles.lib.mediaitem.EditBibleForm', return_value=mocked_edit_bible_form_instance) \
as mocked_edit_bible_form, \
patch.object(self.media_item, 'reload_bibles') as mocked_reload_bibles:
# WHEN: on_edit_click is called, and the user cancels the EditBibleForm
self.media_item.on_edit_click()
# THEN: EditBibleForm should have been been instianted but reload_bibles should not have been called
self.assertTrue(mocked_edit_bible_form.called)
self.assertFalse(mocked_reload_bibles.called)
def test_on_edit_click_user_accepts_edit_form(self):
"""
Test on_edit_click when the user accepts the EditBibleForm
"""
# GIVEN: An instance of :class:`MediaManagerItem` and a mocked EditBibleForm which returns True when exec is
# called
self.media_item.bible = MagicMock()
mocked_edit_bible_form_instance = MagicMock(**{'exec.return_value': True})
with patch('openlp.plugins.bibles.lib.mediaitem.EditBibleForm',
return_value=mocked_edit_bible_form_instance) \
as mocked_edit_bible_form, \
patch.object(self.media_item, 'reload_bibles') as mocked_reload_bibles:
# WHEN: on_edit_click is called, and the user accpets the EditBibleForm
self.media_item.on_edit_click()
# THEN: EditBibleForm should have been been instianted and reload_bibles should have been called
self.assertTrue(mocked_edit_bible_form.called)
self.assertTrue(mocked_reload_bibles.called)
def test_on_delete_click_no_bible(self):
"""
Test on_delete_click when there is no main bible selected
"""
# GIVEN: An instance of :class:`MediaManagerItem`
with patch('openlp.plugins.bibles.lib.mediaitem.QtWidgets.QMessageBox') as mocked_qmessage_box:
# WHEN: A main bible is not selected and on_delete_click is called
self.media_item.bible = None
self.media_item.on_delete_click()
# THEN: QMessageBox.question should not have been called
self.assertFalse(mocked_qmessage_box.question.called)
def test_on_delete_click_response_no(self):
"""
Test on_delete_click when the user selects no from the message box
"""
# GIVEN: An instance of :class:`MediaManagerItem` and a QMessageBox which reutrns QtWidgets.QMessageBox.No
self.media_item.bible = MagicMock()
with patch('openlp.plugins.bibles.lib.mediaitem.QtWidgets.QMessageBox.question',
return_value=QtWidgets.QMessageBox.No) as mocked_qmessage_box:
# WHEN: on_delete_click is called
self.media_item.on_delete_click()
# THEN: QMessageBox.question should have been called, but the delete_bible should not have been called
self.assertTrue(mocked_qmessage_box.called)
self.assertFalse(self.mocked_plugin.manager.delete_bible.called)
def test_on_delete_click_response_yes(self):
"""
Test on_delete_click when the user selects yes from the message box
"""
# GIVEN: An instance of :class:`MediaManagerItem` and a QMessageBox which reutrns QtWidgets.QMessageBox.Yes
self.media_item.bible = MagicMock()
with patch('openlp.plugins.bibles.lib.mediaitem.QtWidgets.QMessageBox.question',
return_value=QtWidgets.QMessageBox.Yes) as mocked_qmessage_box, \
patch.object(self.media_item, 'reload_bibles'):
# WHEN: on_delete_click is called
self.media_item.on_delete_click()
# THEN: QMessageBox.question should and delete_bible should not have been called
self.assertTrue(mocked_qmessage_box.called)
self.assertTrue(self.mocked_plugin.manager.delete_bible.called)
def test_on_search_tab_bar_current_changed_search_tab_selected(self):
"""
Test on_search_tab_bar_current_changed when the search_tab is selected
"""
# GIVEN: An instance of :class:`MediaManagerItem` and mocked out search_tab and select_tab
self.media_item.search_tab = MagicMock()
self.media_item.select_tab = MagicMock()
self.media_item.options_tab = MagicMock()
self.media_item.search_button = MagicMock()
with patch.object(self.media_item, 'on_focus'):
# WHEN: The search_tab has been selected
self.media_item.on_search_tab_bar_current_changed(SearchTabs.Search)
# THEN: The search_button should be enabled, search_tab should be setVisible and select_tab should be hidden
self.media_item.search_button.setEnabled.assert_called_once_with(True)
self.media_item.search_tab.setVisible.assert_called_once_with(True)
self.media_item.select_tab.setVisible.assert_called_once_with(False)
def test_on_search_tab_bar_current_changed_select_tab_selected(self):
"""
Test on_search_tab_bar_current_changed when the select_tab is selected
"""
# GIVEN: An instance of :class:`MediaManagerItem` and mocked out search_tab and select_tab
self.media_item.search_tab = MagicMock()
self.media_item.select_tab = MagicMock()
self.media_item.options_tab = MagicMock()
self.media_item.search_button = MagicMock()
with patch.object(self.media_item, 'on_focus'):
# WHEN: The select_tab has been selected
self.media_item.on_search_tab_bar_current_changed(SearchTabs.Select)
# THEN: The search_button should be enabled, select_tab should be setVisible and search_tab should be hidden
self.media_item.search_button.setEnabled.assert_called_once_with(True)
self.media_item.search_tab.setVisible.assert_called_once_with(False)
self.media_item.select_tab.setVisible.assert_called_once_with(True)
def test_on_book_order_button_toggled_checked(self):
"""
Test that 'on_book_order_button_toggled' changes the order of the book list
"""
self.media_item.select_book_combo_box = MagicMock()
# WHEN: When the book_order_button is checked
self.media_item.on_book_order_button_toggled(True)
# THEN: The select_book_combo_box model should have been sorted
self.media_item.select_book_combo_box.model().sort.assert_called_once_with(0)
def test_on_book_order_button_toggled_un_checked(self):
"""
Test that 'on_book_order_button_toggled' changes the order of the book list
"""
self.media_item.select_book_combo_box = MagicMock()
# WHEN: When the book_order_button is un-checked
self.media_item.on_book_order_button_toggled(False)
# THEN: The select_book_combo_box model sort should have been reset
self.media_item.select_book_combo_box.model().sort.assert_called_once_with(-1)
def test_on_clear_button_clicked(self):
"""
Test on_clear_button_clicked when the search tab is selected
"""
# GIVEN: An instance of :class:`MediaManagerItem` and mocked out search_tab and select_tab and a mocked out
# list_view and search_edit
self.media_item.list_view = MagicMock(**{'selectedItems.return_value': ['Some', 'Results']})
self.media_item.results_view_tab = MagicMock(**{'currentIndex.return_value': ResultsTab.Search})
with patch.object(self.media_item, 'on_results_view_tab_total_update'):
# WHEN: Calling on_clear_button_clicked
self.media_item.on_clear_button_clicked()
# THEN: The list_view and the search_edit should be cleared
self.assertEqual(self.media_item.current_results, [])
self.assertEqual(self.media_item.list_view.takeItem.call_count, 2)
self.media_item.list_view.row.assert_has_calls([call('Some'), call('Results')])
def test_on_save_results_button_clicked(self):
"""
Test that "on_save_results_button_clicked" saves the results.
"""
# GIVEN: An instance of :class:`MediaManagerItem` and a mocked list_view
result_1 = MagicMock(**{'data.return_value': 'R1'})
result_2 = MagicMock(**{'data.return_value': 'R2'})
result_3 = MagicMock(**{'data.return_value': 'R3'})
self.media_item.list_view = MagicMock(**{'selectedItems.return_value': [result_1, result_2, result_3]})
with patch.object(self.media_item, 'on_results_view_tab_total_update') as \
mocked_on_results_view_tab_total_update:
# WHEN: When the save_results_button is clicked
self.media_item.on_save_results_button_clicked()
# THEN: The selected results in the list_view should be added to the 'saved_results' list. And the saved_tab
# total should be updated.
self.assertEqual(self.media_item.saved_results, ['R1', 'R2', 'R3'])
mocked_on_results_view_tab_total_update.assert_called_once_with(ResultsTab.Saved)
def test_on_style_combo_box_changed(self):
"""
Test on_style_combo_box_index_changed
"""
# GIVEN: An instance of :class:`MediaManagerItem` a mocked media_item.settings
self.media_item.settings = MagicMock()
# WHEN: Calling on_style_combo_box_index_changed
self.media_item.on_style_combo_box_index_changed(2)
# THEN: The layput_style settimg should have been set
self.assertEqual(self.media_item.settings.layout_style, 2)
self.media_item.settings.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):
"""
Test on_version_combo_box_index_changed when there is no main bible.
"""
# GIVEN: An instance of :class:`MediaManagerItem` and mocked media_item.settings and select_book_combo_box
self.media_item.version_combo_box = MagicMock(**{'currentData.return_value': None})
self.media_item.select_book_combo_box = MagicMock()
with patch.object(self.media_item, 'initialise_advanced_bible') as mocked_initialise_advanced_bible:
# WHEN: Calling on_version_combo_box_index_changed
self.media_item.on_version_combo_box_index_changed()
# THEN: The vesion should be saved to settings and the 'select tab' should be initialised
self.assertFalse(self.mocked_settings_instance.setValue.called)
self.assertTrue(self.media_item.initialise_advanced_bible.called)
def test_on_version_combo_box_index_changed_bible_selected(self):
"""
Test on_version_combo_box_index_changed when a bible has been selected.
"""
# GIVEN: An instance of :class:`MediaManagerItem` and mocked media_item.settings and select_book_combo_box
mocked_bible_db = MagicMock()
mocked_bible_db.name = 'ABC'
self.media_item.version_combo_box = MagicMock(**{'currentData.return_value': mocked_bible_db})
self.media_item.select_book_combo_box = MagicMock()
with patch.object(self.media_item, 'initialise_advanced_bible') as mocked_initialise_advanced_bible:
# WHEN: Calling on_version_combo_box_index_changed
self.media_item.on_version_combo_box_index_changed()
# THEN: The vesion should be saved to settings and the 'select tab' should be initialised
self.mocked_settings_instance.setValue.assert_called_once_with('bibles/primary bible', 'ABC')
self.assertTrue(self.media_item.initialise_advanced_bible.called)
def test_on_second_combo_box_index_changed_mode_not_changed(self):
"""
Test on_second_combo_box_index_changed when the user does not change from dual mode
results and the user chooses no to the message box
"""
# GIVEN: An instance of :class:`MediaManagerItem`
self.media_item.list_view = MagicMock(**{'count.return_value': 5})
self.media_item.style_combo_box = MagicMock()
self.media_item.select_book_combo_box = MagicMock()
with patch.object(self.media_item, 'initialise_advanced_bible') as mocked_initialise_advanced_bible, \
patch('openlp.plugins.bibles.lib.mediaitem.critical_error_message_box') \
as mocked_critical_error_message_box:
# WHEN: The previously selected bible is one bible and the new selection is annother bible
self.media_item.second_bible = self.mocked_bible_1
self.media_item.second_combo_box = MagicMock(**{'currentData.return_value': self.mocked_bible_2})
self.media_item.on_second_combo_box_index_changed(5)
# THEN: The new bible should now be the current bible
self.assertFalse(mocked_critical_error_message_box.called)
self.media_item.style_combo_box.setEnabled.assert_called_once_with(False)
self.assertEqual(self.media_item.second_bible, self.mocked_bible_2)
def test_on_second_combo_box_index_changed_single_to_dual_user_abort(self):
"""
Test on_second_combo_box_index_changed when the user changes from single to dual bible mode, there are search
results and the user chooses no to the message box
"""
# GIVEN: An instance of :class:`MediaManagerItem`
self.media_item.list_view = MagicMock(**{'count.return_value': 5})
self.media_item.style_combo_box = MagicMock()
self.media_item.select_book_combo_box = MagicMock()
with patch.object(self.media_item, 'initialise_advanced_bible') as mocked_initialise_advanced_bible, \
patch('openlp.plugins.bibles.lib.mediaitem.critical_error_message_box',
return_value=QtWidgets.QMessageBox.No) as mocked_critical_error_message_box:
# WHEN: The previously selected bible is None and the new selection is a bible and the user selects yes
# to the dialog box
self.media_item.second_bible = None
self.media_item.second_combo_box = MagicMock(**{'currentData.return_value': self.mocked_bible_1})
self.media_item.saved_results = ['saved_results']
self.media_item.on_second_combo_box_index_changed(5)
# THEN: The list_view should be cleared and the currently selected bible should not be channged
self.assertTrue(mocked_critical_error_message_box.called)
self.assertTrue(self.media_item.second_combo_box.setCurrentIndex.called)
self.assertFalse(self.media_item.style_combo_box.setEnabled.called)
self.assertEqual(self.media_item.second_bible, None)
def test_on_second_combo_box_index_changed_single_to_dual(self):
"""
Test on_second_combo_box_index_changed when the user changes from single to dual bible mode, there are search
results and the user chooses yes to the message box
"""
# GIVEN: An instance of :class:`MediaManagerItem`
self.media_item.list_view = MagicMock(**{'count.return_value': 5})
self.media_item.style_combo_box = MagicMock()
self.media_item.select_book_combo_box = MagicMock()
self.media_item.search_results = ['list', 'of', 'results']
with patch.object(self.media_item, 'initialise_advanced_bible') as mocked_initialise_advanced_bible, \
patch.object(self.media_item, 'display_results'), \
patch('openlp.plugins.bibles.lib.mediaitem.critical_error_message_box',
return_value=QtWidgets.QMessageBox.Yes) as mocked_critical_error_message_box:
# WHEN: The previously selected bible is None and the new selection is a bible and the user selects yes
# to the dialog box
self.media_item.second_bible = None
self.media_item.second_combo_box = MagicMock(**{'currentData.return_value': self.mocked_bible_1})
self.media_item.saved_results = ['saved_results']
self.media_item.on_second_combo_box_index_changed(5)
# THEN: The selected bible should be set as the current bible
self.assertTrue(mocked_critical_error_message_box.called)
self.media_item.style_combo_box.setEnabled.assert_called_once_with(False)
self.assertTrue(mocked_initialise_advanced_bible.called)
self.assertEqual(self.media_item.second_bible, self.mocked_bible_1)
def test_on_second_combo_box_index_changed_dual_to_single(self):
"""
Test on_second_combo_box_index_changed when the user changes from dual to single bible mode, there are search
results and the user chooses yes to the message box
"""
# GIVEN: An instance of :class:`MediaManagerItem`
self.media_item.list_view = MagicMock(**{'count.return_value': 5})
self.media_item.style_combo_box = MagicMock()
self.media_item.select_book_combo_box = MagicMock()
self.media_item.search_results = ['list', 'of', 'results']
with patch.object(self.media_item, 'initialise_advanced_bible') as mocked_initialise_advanced_bible, \
patch.object(self.media_item, 'display_results'), \
patch('openlp.plugins.bibles.lib.mediaitem.critical_error_message_box',
return_value=QtWidgets.QMessageBox.Yes) as mocked_critical_error_message_box:
# WHEN: The previously is a bible new selection is None and the user selects yes
# to the dialog box
self.media_item.second_bible = self.mocked_bible_1
self.media_item.second_combo_box = MagicMock(**{'currentData.return_value': None})
self.media_item.saved_results = ['saved_results']
self.media_item.on_second_combo_box_index_changed(0)
# THEN: The selected bible should be set as the current bible
self.assertTrue(mocked_critical_error_message_box.called)
self.media_item.style_combo_box.setEnabled.assert_called_once_with(True)
self.assertFalse(mocked_initialise_advanced_bible.called)
self.assertEqual(self.media_item.second_bible, None)
def test_on_advanced_book_combo_box(self):
"""
Test on_advanced_book_combo_box when the book returns 0 for the verse count.
"""
# GIVEN: An instance of :class:`MediaManagerItem` and a mocked get_verse_count_by_book_ref_id which returns 0
self.media_item.select_book_combo_box = MagicMock(**{'currentData.return_value': 2})
self.media_item.bible = self.mocked_bible_1
self.mocked_plugin.manager.get_verse_count_by_book_ref_id.return_value = 0
self.media_item.search_button = MagicMock()
with patch('openlp.plugins.bibles.lib.mediaitem.critical_error_message_box') \
as mocked_critical_error_message_box:
# WHEN: Calling on_advanced_book_combo_box
self.media_item.on_advanced_book_combo_box()
# THEN: The user should be informed that the bible cannot be used and the search button should be disabled
self.mocked_plugin.manager.get_book_by_id.assert_called_once_with('Bible 1', 2)
self.media_item.search_button.setEnabled.assert_called_once_with(False)
self.assertTrue(mocked_critical_error_message_box.called)
def test_on_advanced_book_combo_box_set_up_comboboxes(self):
"""
Test on_advanced_book_combo_box when the book returns 6 for the verse count.
"""
# GIVEN: An instance of :class:`MediaManagerItem` and a mocked get_verse_count_by_book_ref_id which returns 6
self.media_item.from_chapter = 0
self.media_item.to_chapter = 0
self.media_item.from_verse = 0
self.media_item.to_verse = 0
self.media_item.select_book_combo_box = MagicMock(**{'currentData.return_value': 2})
self.media_item.bible = self.mocked_bible_1
self.mocked_plugin.manager.get_verse_count_by_book_ref_id.return_value = 6
self.media_item.select_tab = MagicMock(**{'isVisible.return_value': True})
self.media_item.search_button = MagicMock()
with patch.object(self.media_item, 'adjust_combo_box') as mocked_adjust_combo_box:
# WHEN: Calling on_advanced_book_combo_box
self.media_item.on_advanced_book_combo_box()
# THEN: The verse selection combobox's should be set up
self.mocked_plugin.manager.get_book_by_id.assert_called_once_with('Bible 1', 2)
self.media_item.search_button.setEnabled.assert_called_once_with(True)
self.assertEqual(mocked_adjust_combo_box.call_count, 4)
def test_on_from_chapter_activated_invalid_to_chapter(self):
"""
Test on_from_chapter_activated when the to_chapter is less than the from_chapter
"""
# GIVEN: An instance of :class:`MediaManagerItem`, some mocked comboboxes with test data
self.media_item.chapter_count = 25
self.media_item.bible = self.mocked_bible_1
self.media_item.select_book_combo_box = MagicMock()
self.media_item.from_chapter = MagicMock(**{'currentData.return_value': 10})
self.media_item.to_chapter = MagicMock(**{'currentData.return_value': 5})
self.media_item.from_verse = MagicMock()
self.media_item.to_verse = MagicMock()
self.mocked_plugin.manager.get_verse_count_by_book_ref_id.return_value = 20
with patch.object(self.media_item, 'adjust_combo_box') as mocked_adjust_combo_box:
# WHEN: Calling on_from_chapter_activated
self.media_item.on_from_chapter_activated()
# THEN: The to_verse and to_chapter comboboxes should be updated appropriately
self.assertEqual(mocked_adjust_combo_box.call_args_list, [
call(1, 20, self.media_item.from_verse), call(1, 20, self.media_item.to_verse, False),
call(10, 25, self.media_item.to_chapter, False)])
def test_on_from_chapter_activated_same_chapter(self):
"""
Test on_from_chapter_activated when the to_chapter is the same as from_chapter
"""
# GIVEN: An instance of :class:`MediaManagerItem`, some mocked comboboxes with test data
self.media_item.chapter_count = 25
self.media_item.bible = self.mocked_bible_1
self.media_item.select_book_combo_box = MagicMock()
self.media_item.from_chapter = MagicMock(**{'currentData.return_value': 5})
self.media_item.to_chapter = MagicMock(**{'currentData.return_value': 5})
self.media_item.from_verse = MagicMock()
self.media_item.to_verse = MagicMock()
self.mocked_plugin.manager.get_verse_count_by_book_ref_id.return_value = 20
with patch.object(self.media_item, 'adjust_combo_box') as mocked_adjust_combo_box:
# WHEN: Calling on_from_chapter_activated
self.media_item.on_from_chapter_activated()
# THEN: The to_verse and to_chapter comboboxes should be updated appropriately
self.assertEqual(mocked_adjust_combo_box.call_args_list, [
call(1, 20, self.media_item.from_verse), call(1, 20, self.media_item.to_verse, True),
call(5, 25, self.media_item.to_chapter, False)])
def test_on_from_chapter_activated_lower_chapter(self):
"""
Test on_from_chapter_activated when the to_chapter is greater than the from_chapter
"""
# GIVEN: An instance of :class:`MediaManagerItem`, some mocked comboboxes with test data
self.media_item.chapter_count = 25
self.media_item.bible = self.mocked_bible_1
self.media_item.select_book_combo_box = MagicMock()
self.media_item.from_chapter = MagicMock(**{'currentData.return_value': 5})
self.media_item.to_chapter = MagicMock(**{'currentData.return_value': 7})
self.media_item.from_verse = MagicMock()
self.media_item.to_verse = MagicMock()
self.mocked_plugin.manager.get_verse_count_by_book_ref_id.return_value = 20
with patch.object(self.media_item, 'adjust_combo_box') as mocked_adjust_combo_box:
# WHEN: Calling on_from_chapter_activated
self.media_item.on_from_chapter_activated()
# THEN: The to_verse and to_chapter comboboxes should be updated appropriately
self.assertEqual(mocked_adjust_combo_box.call_args_list, [
call(1, 20, self.media_item.from_verse), call(5, 25, self.media_item.to_chapter, True)])
def test_on_from_verse(self):
"""
Test on_from_verse when the to_chapter is not equal to the from_chapter
"""
# GIVEN: An instance of :class:`MediaManagerItem`, some mocked comboboxes with test data
self.media_item.select_book_combo_box = MagicMock()
self.media_item.from_chapter = MagicMock(**{'currentData.return_value': 2})
self.media_item.to_chapter = MagicMock(**{'currentData.return_value': 5})
# WHEN: Calling on_from_verse
self.media_item.on_from_verse()
# THEN: select_book_combo_box.currentData should nto be called
self.assertFalse(self.media_item.select_book_combo_box.currentData.called)
def test_on_from_verse_equal(self):
"""
Test on_from_verse when the to_chapter is equal to the from_chapter
"""
# GIVEN: An instance of :class:`MediaManagerItem`, some mocked comboboxes with test data
self.media_item.bible = self.mocked_bible_1
self.media_item.select_book_combo_box = MagicMock()
self.media_item.from_chapter = MagicMock(**{'currentData.return_value': 5})
self.media_item.to_chapter = MagicMock(**{'currentData.return_value': 5})
self.media_item.from_verse = MagicMock(**{'currentData.return_value': 7})
self.media_item.to_verse = MagicMock()
self.mocked_plugin.manager.get_verse_count_by_book_ref_id.return_value = 20
with patch.object(self.media_item, 'adjust_combo_box') as mocked_adjust_combo_box:
# WHEN: Calling on_from_verse
self.media_item.on_from_verse()
# THEN: The to_verse should have been updated
mocked_adjust_combo_box.assert_called_once_with(7, 20, self.media_item.to_verse, True)
def test_on_to_chapter_same_chapter_from_greater_than(self):
"""
Test on_to_chapter when the to_chapter is equal to the from_chapter and the from_verse is greater than the
to_verse
"""
# GIVEN: An instance of :class:`MediaManagerItem`, some mocked comboboxes with test data
self.media_item.bible = self.mocked_bible_1
self.media_item.select_book_combo_box = MagicMock()
self.media_item.from_chapter = MagicMock(**{'currentData.return_value': 5})
self.media_item.to_chapter = MagicMock(**{'currentData.return_value': 5})
self.media_item.from_verse = MagicMock(**{'currentData.return_value': 10})
self.media_item.to_verse = MagicMock(**{'currentData.return_value': 7})
self.mocked_plugin.manager.get_verse_count_by_book_ref_id.return_value = 20
with patch.object(self.media_item, 'adjust_combo_box') as mocked_adjust_combo_box:
# WHEN: Calling on_tp_chapter
self.media_item.on_to_chapter()
# THEN: The to_verse should have been updated
mocked_adjust_combo_box.assert_called_once_with(10, 20, self.media_item.to_verse)
def test_on_from_verse_chapters_not_equal(self):
"""
Test on_from_verse when the to_chapter is not equal to the from_chapter
"""
# GIVEN: An instance of :class:`MediaManagerItem`, some mocked comboboxes with test data
self.media_item.bible = self.mocked_bible_1
self.media_item.select_book_combo_box = MagicMock()
self.media_item.from_chapter = MagicMock(**{'currentData.return_value': 7})
self.media_item.to_chapter = MagicMock(**{'currentData.return_value': 5})
self.media_item.from_verse = MagicMock(**{'currentData.return_value': 10})
self.media_item.to_verse = MagicMock(**{'currentData.return_value': 7})
self.mocked_plugin.manager.get_verse_count_by_book_ref_id.return_value = 20
with patch.object(self.media_item, 'adjust_combo_box') as mocked_adjust_combo_box:
# WHEN: Calling on_from_chapter_activated
self.media_item.on_to_chapter()
# THEN: The to_verse should have been updated
mocked_adjust_combo_box.assert_called_once_with(1, 20, self.media_item.to_verse)
def test_on_from_verse_from_verse_less_than(self):
"""
Test on_from_verse when the to_chapter is equal to the from_chapter and from_verse is less than to_verse
"""
# GIVEN: An instance of :class:`MediaManagerItem`, some mocked comboboxes with test data
self.media_item.bible = self.mocked_bible_1
self.media_item.select_book_combo_box = MagicMock()
self.media_item.from_chapter = MagicMock(**{'currentData.return_value': 5})
self.media_item.to_chapter = MagicMock(**{'currentData.return_value': 5})
self.media_item.from_verse = MagicMock(**{'currentData.return_value': 6})
self.media_item.to_verse = MagicMock(**{'currentData.return_value': 7})
self.mocked_plugin.manager.get_verse_count_by_book_ref_id.return_value = 20
with patch.object(self.media_item, 'adjust_combo_box') as mocked_adjust_combo_box:
# WHEN: Calling on_from_chapter_activated
self.media_item.on_to_chapter()
# THEN: The to_verse should have been updated
mocked_adjust_combo_box.assert_called_once_with(1, 20, self.media_item.to_verse)
def test_adjust_combo_box_no_restore(self):
"""
Test adjust_combo_box when being used with out the restore function
"""
# GIVEN: An instance of :class:`MediaManagerItem`
mocked_combo_box = MagicMock()
# WHEN: Calling adjust_combo_box with out setting the kwarg `restore`
self.media_item.adjust_combo_box(10, 13, mocked_combo_box)
# THEN: The combo_box should be cleared, and new items added
mocked_combo_box.clear.assert_called_once_with()
self.assertEqual(mocked_combo_box.addItem.call_args_list,
[call('10', 10), call('11', 11), call('12', 12), call('13', 13)])
def test_adjust_combo_box_restore_found(self):
"""
Test adjust_combo_box when being used with out the restore function
"""
# GIVEN: An instance of :class:`MediaManagerItem`, with the 2nd item '12' selected
mocked_combo_box = MagicMock(**{'currentData.return_value': 12, 'findData.return_value': 2})
# WHEN: Calling adjust_combo_box with the kwarg `restore` set to True
self.media_item.adjust_combo_box(10, 13, mocked_combo_box, True)
# THEN: The combo_box should be cleared, and new items added. Finally the previously selected item should be
# reselected
mocked_combo_box.clear.assert_called_once_with()
self.assertEqual(mocked_combo_box.addItem.call_args_list,
[call('10', 10), call('11', 11), call('12', 12), call('13', 13)])
mocked_combo_box.setCurrentIndex.assert_called_once_with(2)
def test_adjust_combo_box_restore_not_found(self):
"""
Test adjust_combo_box when being used with out the restore function when the selected item is not available
after the combobox has been updated
"""
# GIVEN: An instance of :class:`MediaManagerItem`, with the 2nd item '12' selected
mocked_combo_box = MagicMock(**{'currentData.return_value': 9, 'findData.return_value': -1})
# WHEN: Calling adjust_combo_box with the kwarg `restore` set to True
self.media_item.adjust_combo_box(10, 13, mocked_combo_box, True)
# THEN: The combo_box should be cleared, and new items added. Finally the first item should be selected
mocked_combo_box.clear.assert_called_once_with()
self.assertEqual(mocked_combo_box.addItem.call_args_list,
[call('10', 10), call('11', 11), call('12', 12), call('13', 13)])
mocked_combo_box.setCurrentIndex.assert_called_once_with(0)
def test_on_search_button_no_bible(self):
"""
Test on_search_button_clicked when there is no bible selected
"""
# GIVEN: An instance of :class:`MediaManagerItem`
# WHEN calling on_search_button_clicked and there is no selected bible
self.media_item.bible = None
self.media_item.on_search_button_clicked()
# THEN: The user should be informed that there are no bibles selected
self.assertEqual(self.mocked_main_window.information_message.call_count, 1)
def test_on_search_button_search_tab(self):
"""
Test on_search_button_clicked when the `Search` tab is selected
"""
# GIVEN: An instance of :class:`MediaManagerItem`, and a mocked text_search method
self.media_item.bible = self.mocked_bible_1
self.media_item.search_button = MagicMock()
self.media_item.search_tab = MagicMock(**{'isVisible.return_value': True})
with patch.object(self.media_item, 'text_search') as mocked_text_search:
# WHEN: Calling on_search_button_clicked and the 'Search' tab is selected
self.media_item.on_search_button_clicked()
# THEN: The text_search method should have been called
mocked_text_search.assert_called_once_with()
def test_on_search_button_select_tab(self):
"""
Test on_search_button_clicked when the `Select` tab is selected
"""
# GIVEN: An instance of :class:`MediaManagerItem`, and a mocked select_search method
self.media_item.bible = self.mocked_bible_1
self.media_item.search_button = MagicMock()
self.media_item.search_tab = MagicMock(**{'isVisible.return_value': False})
self.media_item.select_tab = MagicMock(**{'isVisible.return_value': True})
with patch.object(self.media_item, 'select_search') as mocked_select_search:
# WHEN: Calling on_search_button_clicked and the 'Select' tab is selected
self.media_item.on_search_button_clicked()
# THEN: The text_search method should have been called
mocked_select_search.assert_called_once_with()
def test_select_search_single_bible(self):
"""
Test select_search when only one bible is selected
"""
# GIVEN: An instance of :class:`MediaManagerItem` and mocked plugin.manager.get_verses
self.media_item.select_book_combo_box = MagicMock()
self.media_item.from_chapter = MagicMock()
self.media_item.from_verse = MagicMock()
self.media_item.to_chapter = MagicMock()
self.media_item.to_verse = MagicMock()
with patch.object(self.media_item, 'display_results') as mocked_display_results:
# WHEN: Calling select_search and there is only one bible selected
self.media_item.bible = self.mocked_bible_1
self.media_item.second_bible = None
self.media_item.select_search()
# THEN: reference_search should only be called once
self.assertEqual(self.mocked_plugin.manager.get_verses.call_count, 1)
mocked_display_results.assert_called_once_with()
def test_select_search_dual_bibles(self):
"""
Test select_search when two bibles are selected
"""
# GIVEN: An instance of :class:`MediaManagerItem` and mocked_reference_search
self.media_item.select_book_combo_box = MagicMock()
self.media_item.from_chapter = MagicMock()
self.media_item.from_verse = MagicMock()
self.media_item.to_chapter = MagicMock()
self.media_item.to_verse = MagicMock()
with patch.object(self.media_item, 'display_results') as mocked_display_results:
# WHEN: Calling select_search and there are two bibles selected
self.media_item.bible = self.mocked_bible_1
self.media_item.second_bible = self.mocked_bible_2
self.media_item.select_search()
# THEN: reference_search should be called twice
self.assertEqual(self.mocked_plugin.manager.get_verses.call_count, 2)
mocked_display_results.assert_called_once_with()
def test_text_reference_search_single_bible(self):
"""
Test text_reference_search when only one bible is selected
"""
# GIVEN: An instance of :class:`MediaManagerItem` and mocked plugin.manager.get_verses
with patch.object(self.media_item, 'display_results') as mocked_display_results:
# WHEN: Calling text_reference_search with only one bible selected
self.media_item.bible = self.mocked_bible_1
self.media_item.second_bible = None
self.media_item.text_reference_search('Search Text')
# THEN: reference_search should only be called once
self.assertEqual(self.mocked_plugin.manager.get_verses.call_count, 1)
mocked_display_results.assert_called_once_with()
def text_reference_search(self, search_text, search_while_type=False):
"""
We are doing a 'Reference Search'.
This search is called on def text_search by Reference and Combined Searches.
"""
verse_refs = self.plugin.manager.parse_ref(self.bible.name, search_text)
self.search_results = self.reference_search(verse_refs, self.bible)
if self.second_bible and self.search_results:
self.second_search_results = self.reference_search(verse_refs, self.second_bible)
self.display_results()
def test_text_reference_search_dual_bible_no_results(self):
"""
Test text_reference_search when two bible are selected, but the search of the first bible does not return any
results
"""
# GIVEN: An instance of :class:`MediaManagerItem` and mocked plugin.manager.get_verses
# WHEN: Calling text_reference_search with two bibles selected, but no results are found in the first bible
with patch.object(self.media_item, 'display_results') as mocked_display_results:
self.mocked_plugin.manager.get_verses.return_value = []
self.media_item.bible = self.mocked_bible_1
self.media_item.second_bible = self.mocked_bible_2
self.media_item.text_reference_search('Search Text')
# THEN: reference_search should only be called once
self.assertEqual(self.mocked_plugin.manager.get_verses.call_count, 1)
mocked_display_results.assert_called_once_with()
def test_text_reference_search_dual_bible(self):
"""
Test text_reference_search when two bible are selected
"""
# GIVEN: An instance of :class:`MediaManagerItem` and mocked plugin.manager.get_verses
with patch.object(self.media_item, 'display_results') as mocked_display_results:
self.media_item.bible = self.mocked_bible_1
self.media_item.second_bible = self.mocked_bible_2
# WHEN: Calling text_reference_search with two bibles selected
self.media_item.text_reference_search('Search Text')
# THEN: reference_search should be called twice
self.assertEqual(self.mocked_plugin.manager.get_verses.call_count, 2)
mocked_display_results.assert_called_once_with()
def test_on_text_search_single_bible(self):
"""
Test on_text_search when only one bible is selected
"""
# GIVEN: An instance of :class:`MediaManagerItem`
self.media_item.bible = self.mocked_bible_1
self.media_item.second_bible = None
# WHEN: Calling on_text_search and plugin.manager.verse_search returns a list of results
self.mocked_plugin.manager.verse_search.return_value = ['results', 'list']
with patch.object(self.media_item, 'display_results') as mocked_display_results:
self.media_item.on_text_search('Search Text')
# THEN: The search results should be the same as those returned by plugin.manager.verse_search
self.assertEqual(self.media_item.search_results, ['results', 'list'])
mocked_display_results.assert_called_once_with()
def test_on_text_search_no_results(self):
"""
Test on_text_search when the search of the first bible does not return any results
"""
# GIVEN: An instance of :class:`MediaManagerItem`
self.media_item.bible = self.mocked_bible_1
self.media_item.second_bible = self.mocked_bible_2
# WHEN: Calling on_text_search and plugin.manager.verse_search returns an empty list
self.mocked_plugin.manager.verse_search.return_value = []
with patch.object(self.media_item, 'display_results') as mocked_display_results:
self.media_item.on_text_search('Search Text')
# THEN: The search results should be an empty list
self.assertEqual(self.media_item.search_results, [])
mocked_display_results.assert_called_once_with()
def test_on_text_search_all_results_in_both_books(self):
"""
Test on_text_search when all of the results from the first bible are found in the second
"""
# GIVEN: An instance of :class:`MediaManagerItem` and some test data
mocked_verse_1 = MagicMock(**{'book.book_reference_id': 1, 'chapter': 2, 'verse': 3})
mocked_verse_1a = MagicMock(**{'book.book_reference_id': 1, 'chapter': 2, 'verse': 3})
mocked_verse_2 = MagicMock(**{'book.book_reference_id': 4, 'chapter': 5, 'verse': 6})
mocked_verse_2a = MagicMock(**{'book.book_reference_id': 4, 'chapter': 5, 'verse': 6})
self.media_item.bible = self.mocked_bible_1
self.media_item.second_bible = self.mocked_bible_2
self.media_item.second_search_results = []
# WHEN: Calling on_text_search and plugin.manager.verse_search returns a list of search results
self.mocked_plugin.manager.verse_search.return_value = [mocked_verse_1, mocked_verse_2]
self.media_item.second_bible.get_verses.side_effect = [[mocked_verse_1a], [mocked_verse_2a]]
with patch.object(self.media_item, 'display_results') as mocked_display_results:
self.media_item.on_text_search('Search Text')
# THEN: The search results for both bibles should be returned
self.assertEqual(self.media_item.search_results, [mocked_verse_1, mocked_verse_2])
self.assertEqual(self.media_item.second_search_results, [mocked_verse_1a, mocked_verse_2a])
self.assertFalse(self.mocked_log.debug.called)
self.assertFalse(self.mocked_main_window.information_message.called)
mocked_display_results.assert_called_once_with()
def test_on_text_search_not_all_results_in_both_books(self):
"""
Test on_text_search when not all of the results from the first bible are found in the second
"""
# GIVEN: An instance of :class:`MediaManagerItem` and some test data
mocked_verse_1 = MagicMock(**{'book.book_reference_id': 1, 'chapter': 2, 'verse': 3})
mocked_verse_1a = MagicMock(**{'book.book_reference_id': 1, 'chapter': 2, 'verse': 3})
mocked_verse_2 = MagicMock(**{'book.book_reference_id': 4, 'chapter': 5, 'verse': 6})
mocked_verse_3 = MagicMock(**{'book.book_reference_id': 7, 'chapter': 8, 'verse': 9})
self.media_item.bible = self.mocked_bible_1
self.media_item.second_bible = self.mocked_bible_2
self.media_item.second_search_results = []
# WHEN: Calling on_text_search and not all results are found in the second bible
self.mocked_plugin.manager.verse_search.return_value = [mocked_verse_1, mocked_verse_2, mocked_verse_3]
self.media_item.second_bible.get_verses.side_effect = [[mocked_verse_1a], [], []]
with patch.object(self.media_item, 'display_results') as mocked_display_results:
self.media_item.on_text_search('Search Text')
# THEN: The search results included in both bibles should be returned and the user should be notified of
# the missing verses
self.assertEqual(self.media_item.search_results, [mocked_verse_1])
self.assertEqual(self.media_item.second_search_results, [mocked_verse_1a])
self.assertEqual(self.mocked_log.debug.call_count, 2)
self.assertTrue(self.mocked_main_window.information_message.called)
mocked_display_results.assert_called_once_with()
# TODO: Test text_search
def test_on_search_edit_text_changed_search_while_typing_disabled(self):
"""
Test on_search_edit_text_changed when 'search while typing' is disabled
"""
# GIVEN: An instance of BibleMediaItem and mocked Settings which returns False when the value
# 'bibles/is search while typing enabled' is requested
self.setting_values = {'bibles/is search while typing enabled': False}
self.mocked_qtimer.isActive.return_value = False
# WHEN: Calling on_search_edit_text_changed
self.media_item.on_search_edit_text_changed()
# THEN: The method should not have checked if the timer is active
self.assertFalse(self.media_item.search_timer.isActive.called)
def test_on_search_edit_text_changed_search_while_typing_enabled(self):
"""
Test on_search_edit_text_changed when 'search while typing' is enabled
"""
# GIVEN: An instance of BibleMediaItem and mocked Settings which returns True when the value
# 'bibles/is search while typing enabled' is requested
self.setting_values = {'bibles/is search while typing enabled': True}
self.media_item.search_timer.isActive.return_value = False
self.media_item.bible = self.mocked_bible_1
self.media_item.bible.is_web_bible = False
# WHEN: Calling on_search_edit_text_changed
self.media_item.on_search_edit_text_changed()
# THEN: The method should start the search_timer
self.media_item.search_timer.isActive.assert_called_once_with()
self.media_item.search_timer.start.assert_called_once_with()
def test_on_search_timer_timeout(self):
"""
Test on_search_timer_timeout
"""
# GIVEN: An instance of BibleMediaItem
with patch.object(self.media_item, 'text_search') as mocked_text_search:
# WHEN: Calling on_search_timer_timeout
self.media_item.on_search_timer_timeout()
# THEN: The search_status should be set to SearchAsYouType and text_search should have been called
self.assertEqual(self.media_item.search_status, SearchStatus.SearchAsYouType)
mocked_text_search.assert_called_once_with()
def test_display_results_no_results(self):
"""
Test the display_results method when there are no items to display
"""
# GIVEN: An instance of BibleMediaItem and a mocked build_display_results which returns an empty list
self.media_item.list_view = MagicMock()
self.media_item.bible = self.mocked_bible_1
self.media_item.second_bible = self.mocked_bible_2
self.media_item.search_results = []
with patch.object(self.media_item, 'build_display_results', return_value=[]):
# WHEN: Calling display_results with True
self.media_item.display_results()
# THEN: No items should be added to the list
self.assertFalse(self.media_item.list_view.addItem.called)
def test_display_results_results(self):
"""
Test the display_results method when there are items to display
"""
# GIVEN: An instance of BibleMediaItem and a mocked build_display_results which returns a list of results
with patch.object(self.media_item, 'build_display_results', return_value=[
{'item_title': 'Title 1'}, {'item_title': 'Title 2'}]), \
patch.object(self.media_item, 'add_built_results_to_list_widget') as \
mocked_add_built_results_to_list_widget:
self.media_item.search_results = ['results']
self.media_item.list_view = MagicMock()
# WHEN: Calling display_results
self.media_item.display_results()
# THEN: addItem should have been with the display items
mocked_add_built_results_to_list_widget.assert_called_once_with(
[{'item_title': 'Title 1'}, {'item_title': 'Title 2'}])