openlp/tests/functional/openlp_plugins/bibles/test_mediaitem.py

1462 lines
75 KiB
Python
Raw Normal View History

2014-12-19 22:02:45 +00:00
# -*- coding: utf-8 -*-
# vim: autoindent shiftwidth=4 expandtab textwidth=120 tabstop=4 softtabstop=4
###############################################################################
# OpenLP - Open Source Lyrics Projection #
# --------------------------------------------------------------------------- #
2019-02-14 15:09:09 +00:00
# Copyright (c) 2008-2019 OpenLP Developers #
2014-12-19 22:02:45 +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; 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
2016-12-18 14:01:05 +00:00
from unittest.mock import MagicMock, call, patch
from PyQt5 import QtCore, QtWidgets
2017-10-07 07:05:07 +00:00
from openlp.core.common.registry import Registry
from openlp.core.lib.mediamanageritem import MediaManagerItem
2018-10-02 04:39:42 +00:00
from openlp.plugins.bibles.lib.mediaitem import VALID_TEXT_SEARCH, BibleMediaItem, BibleSearch, ResultsTab, \
SearchStatus, SearchTabs, get_reference_separators
2017-12-28 08:22:55 +00:00
from tests.helpers.testmixin import TestMixin
2016-12-18 14:01:05 +00:00
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:
2017-12-22 21:04:29 +00:00
assert result is None, expected_result
2016-12-18 14:01:05 +00:00
else:
2017-12-22 21:04:29 +00:00
assert result.regs == expected_result
2016-12-18 14:01:05 +00:00
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.
2017-12-22 21:04:29 +00:00
assert all(key in result for key in ('verse', 'range', 'list')) is True
2016-12-18 14:01:05 +00:00
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
2017-12-22 21:04:29 +00:00
assert hasattr(BibleSearch, 'Combined')
assert hasattr(BibleSearch, 'Reference')
assert hasattr(BibleSearch, 'Text')
2016-12-18 14:01:05 +00:00
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
2017-12-22 21:04:29 +00:00
assert issubclass(BibleMediaItem, MediaManagerItem)
2016-12-18 14:01:05 +00:00
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
2017-12-22 21:04:29 +00:00
assert hasattr(BibleMediaItem, 'bibles_go_live')
assert hasattr(BibleMediaItem, 'bibles_add_to_service')
assert isinstance(BibleMediaItem.bibles_go_live, QtCore.pyqtSignal)
assert isinstance(BibleMediaItem.bibles_add_to_service, QtCore.pyqtSignal)
2016-12-18 14:01:05 +00:00
2014-12-19 22:02:45 +00:00
class TestMediaItem(TestCase, TestMixin):
"""
Test the bible mediaitem methods.
"""
def setUp(self):
"""
Set up the components need for all tests.
"""
2016-12-18 14:01:05 +00:00
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()
2014-12-19 22:02:45 +00:00
2016-12-18 18:42:28 +00:00
# self.setup_application()
2016-12-18 14:01:05 +00:00
self.mocked_application = MagicMock()
Registry().register('application', self.mocked_application)
self.mocked_main_window = MagicMock()
Registry().register('main_window', self.mocked_main_window)
2014-12-19 22:02:45 +00:00
2016-12-18 14:01:05 +00:00
self.mocked_plugin = MagicMock()
2018-06-10 19:29:00 +00:00
with patch('openlp.plugins.bibles.lib.mediaitem.MediaManagerItem._setup'), \
2016-12-18 18:47:54 +00:00
patch('openlp.plugins.bibles.lib.mediaitem.BibleMediaItem.setup_item'):
2016-12-18 14:01:05 +00:00
self.media_item = BibleMediaItem(None, self.mocked_plugin)
2014-12-19 22:02:45 +00:00
2016-12-18 14:01:05 +00:00
self.media_item.settings_section = 'bibles'
self.media_item.results_view_tab = MagicMock()
2014-12-19 22:02:45 +00:00
2016-12-18 14:01:05 +00:00
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})
2014-12-19 22:02:45 +00:00
2016-12-18 14:01:05 +00:00
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'
2014-12-19 22:02:45 +00:00
2016-12-18 14:01:05 +00:00
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`
2017-12-22 21:04:29 +00:00
assert isinstance(self.media_item, MediaManagerItem)
2014-12-19 22:02:45 +00:00
2018-01-27 09:41:11 +00:00
def test_setup_item(self):
2016-12-18 14:01:05 +00:00
"""
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.
2014-12-19 22:02:45 +00:00
2016-12-18 14:01:05 +00:00
# GIVEN: A mocked Registry.register_function method and an instance of BibleMediaItem
with patch.object(Registry(), 'register_function') as mocked_register_function:
2014-12-19 22:02:45 +00:00
2016-12-18 14:01:05 +00:00
# WHEN: Calling setup_itme
self.media_item.setup_item()
2014-12-19 22:02:45 +00:00
2016-12-18 14:01:05 +00:00
# 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)
2016-08-20 19:14:15 +00:00
def test_required_icons(self):
"""
Test that all the required icons are set properly.
"""
2016-12-18 14:01:05 +00:00
# GIVEN: An instance of :class:`MediaManagerItem`
# WHEN: required_icons is called
2016-08-20 19:14:15 +00:00
self.media_item.required_icons()
2016-12-18 14:01:05 +00:00
# THEN: The correct icons should be set
2017-12-22 21:04:29 +00:00
assert self.media_item.has_import_icon is True, 'Check that the icon is as True.'
assert self.media_item.has_new_icon is False, 'Check that the icon is called as False.'
assert self.media_item.has_edit_icon is True, 'Check that the icon is called as True.'
assert self.media_item.has_delete_icon is True, 'Check that the icon is called as True.'
assert self.media_item.add_to_service_item is False, 'Check that the icon is called as False'
2016-08-20 19:14:15 +00:00
2016-12-18 14:01:05 +00:00
def test_on_focus_search_tab_visible(self):
"""
2016-12-18 14:01:05 +00:00
Test the correct widget gets focus when the BibleMediaItem receives focus
"""
2017-06-03 22:34:19 +00:00
# GIVEN: An instance of :class:`MediaManagerItem` and mocked out tabs and primary widgets
2016-12-18 14:01:05 +00:00
self.media_item.search_tab = MagicMock(**{'isVisible.return_value': True})
self.media_item.search_edit = MagicMock()
2017-06-03 22:34:19 +00:00
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()
2016-12-18 14:01:05 +00:00
# WHEN: Calling on_focus
self.media_item.on_focus()
2017-06-03 22:34:19 +00:00
# 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()
2016-12-18 14:01:05 +00:00
2017-06-03 22:34:19 +00:00
def test_on_focus_select_tab_visible(self):
2016-12-18 14:01:05 +00:00
"""
Test the correct widget gets focus when the BibleMediaItem receives focus
"""
2017-06-03 22:34:19 +00:00
# GIVEN: An instance of :class:`MediaManagerItem` and mocked out tabs and primary widgets
2016-12-18 14:01:05 +00:00
self.media_item.search_tab = MagicMock(**{'isVisible.return_value': False})
2017-06-03 22:34:19 +00:00
self.media_item.search_edit = MagicMock()
self.media_item.select_tab = MagicMock(**{'isVisible.return_value': True})
2016-12-18 14:01:05 +00:00
self.media_item.select_book_combo_box = MagicMock()
2017-06-03 22:34:19 +00:00
self.media_item.options_tab = MagicMock(**{'isVisible.return_value': False})
self.media_item.version_combo_box = MagicMock()
2016-12-18 14:01:05 +00:00
# WHEN: Calling on_focus
self.media_item.on_focus()
2017-06-03 22:34:19 +00:00
# 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()
2016-12-18 14:01:05 +00:00
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}
2016-12-18 18:42:28 +00:00
with patch.object(self.media_item, 'populate_bible_combo_boxes'), \
patch.object(self.media_item, 'config_update'):
2016-12-18 14:01:05 +00:00
self.media_item.search_edit = MagicMock()
# WHEN: Calling initialise()
self.media_item.initialise()
# THEN: The search_edit search types should have been set.
2017-12-22 21:04:29 +00:00
assert self.media_item.search_edit.set_search_types.called is True
assert self.media_item.search_edit.set_current_search_type.called is False
2016-12-18 14:01:05 +00:00
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}
2016-12-18 18:42:28 +00:00
with patch.object(self.media_item, 'populate_bible_combo_boxes'), \
patch.object(self.media_item, 'config_update'):
2016-12-18 14:01:05 +00:00
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'
2017-12-22 21:04:29 +00:00
assert self.media_item.search_edit.set_search_types.called is True
2016-12-18 14:01:05 +00:00
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), \
2016-12-18 18:42:28 +00:00
patch('openlp.plugins.bibles.lib.mediaitem.find_and_set_in_combo_box'):
2016-12-18 14:01:05 +00:00
# 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
2017-12-22 21:04:29 +00:00
assert result == self.book_list_1
2016-12-18 14:01:05 +00:00
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
2017-12-22 21:04:29 +00:00
assert result == [self.mocked_book_2, self.mocked_book_3]
2016-12-18 14:01:05 +00:00
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
2017-12-22 21:04:29 +00:00
assert result is None
2016-12-18 14:01:05 +00:00
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
2016-12-18 18:42:28 +00:00
self.media_item.select_book_combo_box = MagicMock(**{'findData.return_value': 2})
2016-12-18 14:01:05 +00:00
with patch.object(self.media_item, 'get_common_books', return_value=self.book_list_1), \
2016-12-18 18:47:54 +00:00
patch.object(self.media_item, 'on_advanced_book_combo_box'):
2016-12-18 14:01:05 +00:00
# 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
2016-12-18 18:42:28 +00:00
self.media_item.select_book_combo_box = MagicMock(**{'findData.return_value': -1})
2016-12-18 14:01:05 +00:00
with patch.object(self.media_item, 'get_common_books', return_value=self.book_list_1), \
2016-12-18 18:42:28 +00:00
patch.object(self.media_item, 'on_advanced_book_combo_box'):
2016-12-18 14:01:05 +00:00
# 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()
2017-06-04 15:21:25 +00:00
# THEN: set_case_insensitive_completer should have been called with the names of the books + space in order
2016-12-18 14:01:05 +00:00
mocked_set_case_insensitive_completer.assert_called_once_with(
2017-06-04 15:21:25 +00:00
['Book 1 ', 'Book 2 ', 'Book 3 '], mocked_search_edit)
2016-12-18 14:01:05 +00:00
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), \
2016-12-18 18:42:28 +00:00
patch('openlp.plugins.bibles.lib.mediaitem.get_locale_key', side_effect=lambda x: x), \
patch('openlp.plugins.bibles.lib.mediaitem.set_case_insensitive_completer') \
2016-12-18 14:01:05 +00:00
as mocked_set_case_insensitive_completer:
2016-12-18 18:42:28 +00:00
2016-12-18 14:01:05 +00:00
# WHEN: Calling update_auto_completer
self.media_item.update_auto_completer()
2017-06-04 15:21:25 +00:00
# THEN: set_case_insensitive_completer should have been called with the names of the books + space in order
2016-12-18 14:01:05 +00:00
mocked_set_case_insensitive_completer.assert_called_once_with(
2017-06-04 15:21:25 +00:00
['Book 1 ', 'Book 2 ', 'Book 3 '], mocked_search_edit)
2016-12-18 14:01:05 +00:00
def test_on_import_click_no_import_wizard_attr(self):
2016-12-18 14:01:05 +00:00
"""
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
2017-12-22 21:04:29 +00:00
assert mocked_bible_import_form.called is True
assert mocked_reload_bibles.called is False
2016-12-18 14:01:05 +00:00
def test_on_import_click_wizard_not_canceled(self):
2016-12-18 14:01:05 +00:00
"""
Test on_import_click when the media item has the import_wizard attr set and wizard completes sucessfully.
2016-12-18 14:01:05 +00:00
"""
# 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
2017-12-22 21:04:29 +00:00
assert mocked_import_wizard.called is False
assert mocked_reload_bibles.called is True
2016-12-18 14:01:05 +00:00
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
2017-12-22 21:04:29 +00:00
assert mocked_edit_bible_form.called is False
2016-12-18 14:01:05 +00:00
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, \
2016-12-18 18:42:28 +00:00
patch.object(self.media_item, 'reload_bibles') as mocked_reload_bibles:
2016-12-18 14:01:05 +00:00
# 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
2017-12-22 21:04:29 +00:00
assert mocked_edit_bible_form.called is True
assert mocked_reload_bibles.called is False
2016-12-18 14:01:05 +00:00
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
2017-12-22 21:04:29 +00:00
assert mocked_edit_bible_form.called is True
assert mocked_reload_bibles.called is True
2016-12-18 14:01:05 +00:00
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
2017-12-22 21:04:29 +00:00
assert mocked_qmessage_box.question.called is False
2016-12-18 14:01:05 +00:00
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
2017-12-22 21:04:29 +00:00
assert mocked_qmessage_box.called is True
assert self.mocked_plugin.manager.delete_bible.called is False
2016-12-18 14:01:05 +00:00
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',
2016-12-18 18:47:54 +00:00
return_value=QtWidgets.QMessageBox.Yes) as mocked_qmessage_box, \
2016-12-18 18:42:28 +00:00
patch.object(self.media_item, 'reload_bibles'):
2016-12-18 14:01:05 +00:00
# WHEN: on_delete_click is called
self.media_item.on_delete_click()
# THEN: QMessageBox.question should and delete_bible should not have been called
2017-12-22 21:04:29 +00:00
assert mocked_qmessage_box.called is True
assert self.mocked_plugin.manager.delete_bible.called is True
2016-12-18 14:01:05 +00:00
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()
2017-06-03 22:34:19 +00:00
self.media_item.options_tab = MagicMock()
self.media_item.search_button = MagicMock()
2016-12-18 14:01:05 +00:00
with patch.object(self.media_item, 'on_focus'):
# WHEN: The search_tab has been selected
2017-06-03 22:34:19 +00:00
self.media_item.on_search_tab_bar_current_changed(SearchTabs.Search)
2016-12-18 14:01:05 +00:00
2017-06-03 22:34:19 +00:00
# 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)
2016-12-18 14:01:05 +00:00
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()
2017-06-03 22:34:19 +00:00
self.media_item.options_tab = MagicMock()
self.media_item.search_button = MagicMock()
2016-12-18 14:01:05 +00:00
with patch.object(self.media_item, 'on_focus'):
# WHEN: The select_tab has been selected
2017-06-03 22:34:19 +00:00
self.media_item.on_search_tab_bar_current_changed(SearchTabs.Select)
2016-12-18 14:01:05 +00:00
2017-06-03 22:34:19 +00:00
# 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)
2016-12-18 14:01:05 +00:00
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
"""
2016-12-18 18:42:28 +00:00
self.media_item.select_book_combo_box = MagicMock()
2016-12-18 14:01:05 +00:00
# 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
"""
2016-12-18 18:42:28 +00:00
self.media_item.select_book_combo_box = MagicMock()
2016-12-18 14:01:05 +00:00
# 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)
2016-08-19 22:49:51 +00:00
2017-06-03 22:34:19 +00:00
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
2017-06-03 22:34:19 +00:00
self.media_item.list_view = MagicMock(**{'selectedItems.return_value': ['Some', 'Results']})
self.media_item.results_view_tab = MagicMock(**{'currentIndex.return_value': ResultsTab.Search})
2017-06-03 22:34:19 +00:00
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
2017-12-22 21:04:29 +00:00
assert self.media_item.current_results == []
assert self.media_item.list_view.takeItem.call_count == 2
2017-06-03 22:34:19 +00:00
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]})
2016-12-18 14:01:05 +00:00
with patch.object(self.media_item, 'on_results_view_tab_total_update') as \
2017-04-03 20:28:16 +00:00
mocked_on_results_view_tab_total_update:
2016-12-18 14:01:05 +00:00
# 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.
2017-12-22 21:04:29 +00:00
assert self.media_item.saved_results == ['R1', 'R2', 'R3']
mocked_on_results_view_tab_total_update.assert_called_once_with(ResultsTab.Saved)
2016-12-18 14:01:05 +00:00
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)
2017-12-22 21:04:29 +00:00
# THEN: The layout_style setting should have been set
2017-12-24 07:11:30 +00:00
assert self.media_item.settings.layout_style == 2
2016-12-18 14:01:05 +00:00
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()
2018-10-27 01:40:20 +00:00
with patch.object(self.media_item, 'initialise_advanced_bible'):
2016-12-18 14:01:05 +00:00
# WHEN: Calling on_version_combo_box_index_changed
self.media_item.on_version_combo_box_index_changed()
2017-12-22 21:04:29 +00:00
# THEN: The version should be saved to settings and the 'select tab' should be initialised
assert self.mocked_settings_instance.setValue.called is False
assert self.media_item.initialise_advanced_bible.called is True
2016-12-18 14:01:05 +00:00
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()
2016-12-18 18:42:28 +00:00
mocked_bible_db.name = 'ABC'
2016-12-18 14:01:05 +00:00
self.media_item.version_combo_box = MagicMock(**{'currentData.return_value': mocked_bible_db})
self.media_item.select_book_combo_box = MagicMock()
2018-10-27 01:40:20 +00:00
with patch.object(self.media_item, 'initialise_advanced_bible'):
2016-12-18 14:01:05 +00:00
# WHEN: Calling on_version_combo_box_index_changed
self.media_item.on_version_combo_box_index_changed()
2017-12-22 21:04:29 +00:00
# THEN: The version should be saved to settings and the 'select tab' should be initialised
2016-12-18 14:01:05 +00:00
self.mocked_settings_instance.setValue.assert_called_once_with('bibles/primary bible', 'ABC')
2017-12-22 21:04:29 +00:00
assert self.media_item.initialise_advanced_bible.called is True
2016-12-18 14:01:05 +00:00
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()
2018-10-27 01:40:20 +00:00
with patch.object(self.media_item, 'initialise_advanced_bible'), \
2016-12-18 14:01:05 +00:00
patch('openlp.plugins.bibles.lib.mediaitem.critical_error_message_box') \
2016-12-18 18:42:28 +00:00
as mocked_critical_error_message_box:
2016-12-18 14:01:05 +00:00
2017-12-22 21:04:29 +00:00
# WHEN: The previously selected bible is one bible and the new selection is another bible
2016-12-18 14:01:05 +00:00
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
2017-12-22 21:04:29 +00:00
assert mocked_critical_error_message_box.called is False
2016-12-18 14:01:05 +00:00
self.media_item.style_combo_box.setEnabled.assert_called_once_with(False)
2017-12-22 21:04:29 +00:00
assert self.media_item.second_bible == self.mocked_bible_2
2016-12-18 14:01:05 +00:00
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()
2018-10-27 01:40:20 +00:00
with patch.object(self.media_item, 'initialise_advanced_bible'), \
2016-12-18 14:01:05 +00:00
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})
2017-06-03 22:34:19 +00:00
self.media_item.saved_results = ['saved_results']
2016-12-18 14:01:05 +00:00
self.media_item.on_second_combo_box_index_changed(5)
2017-12-22 21:04:29 +00:00
# THEN: The list_view should be cleared and the currently selected bible should not be changed
assert mocked_critical_error_message_box.called is True
assert self.media_item.second_combo_box.setCurrentIndex.called is True
assert self.media_item.style_combo_box.setEnabled.called is False
assert self.media_item.second_bible is None
2016-12-18 14:01:05 +00:00
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']
2016-12-18 14:01:05 +00:00
with patch.object(self.media_item, 'initialise_advanced_bible') as mocked_initialise_advanced_bible, \
patch.object(self.media_item, 'display_results'), \
2016-12-18 14:01:05 +00:00
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})
2017-06-03 22:34:19 +00:00
self.media_item.saved_results = ['saved_results']
2016-12-18 14:01:05 +00:00
self.media_item.on_second_combo_box_index_changed(5)
# THEN: The selected bible should be set as the current bible
2017-12-22 21:04:29 +00:00
assert mocked_critical_error_message_box.called is True
2016-12-18 14:01:05 +00:00
self.media_item.style_combo_box.setEnabled.assert_called_once_with(False)
2017-12-22 21:04:29 +00:00
assert mocked_initialise_advanced_bible.called is True
assert self.media_item.second_bible == self.mocked_bible_1
2016-12-18 14:01:05 +00:00
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']
2016-12-18 14:01:05 +00:00
with patch.object(self.media_item, 'initialise_advanced_bible') as mocked_initialise_advanced_bible, \
patch.object(self.media_item, 'display_results'), \
2016-12-18 14:01:05 +00:00
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})
2017-06-03 22:34:19 +00:00
self.media_item.saved_results = ['saved_results']
2016-12-18 14:01:05 +00:00
self.media_item.on_second_combo_box_index_changed(0)
# THEN: The selected bible should be set as the current bible
2017-12-22 21:04:29 +00:00
assert mocked_critical_error_message_box.called is True
2016-12-18 14:01:05 +00:00
self.media_item.style_combo_box.setEnabled.assert_called_once_with(True)
2017-12-22 21:04:29 +00:00
assert mocked_initialise_advanced_bible.called is False
assert self.media_item.second_bible is None
2016-12-18 14:01:05 +00:00
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)
2017-12-22 21:04:29 +00:00
assert mocked_critical_error_message_box.called is True
2016-12-18 14:01:05 +00:00
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
2017-06-03 22:34:19 +00:00
self.media_item.select_tab = MagicMock(**{'isVisible.return_value': True})
2016-12-18 14:01:05 +00:00
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)
2017-12-22 21:04:29 +00:00
assert mocked_adjust_combo_box.call_count == 4
2016-12-18 14:01:05 +00:00
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
2017-12-22 21:04:29 +00:00
assert mocked_adjust_combo_box.call_args_list == [
2016-12-18 14:01:05 +00:00
call(1, 20, self.media_item.from_verse), call(1, 20, self.media_item.to_verse, False),
2017-12-22 21:04:29 +00:00
call(10, 25, self.media_item.to_chapter, False)]
2016-12-18 14:01:05 +00:00
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
2017-12-22 21:04:29 +00:00
assert mocked_adjust_combo_box.call_args_list == [
2016-12-18 14:01:05 +00:00
call(1, 20, self.media_item.from_verse), call(1, 20, self.media_item.to_verse, True),
2017-12-22 21:04:29 +00:00
call(5, 25, self.media_item.to_chapter, False)]
2016-12-18 14:01:05 +00:00
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
2017-12-22 21:04:29 +00:00
assert mocked_adjust_combo_box.call_args_list == [
call(1, 20, self.media_item.from_verse), call(5, 25, self.media_item.to_chapter, True)]
2016-12-18 14:01:05 +00:00
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
2017-12-22 21:04:29 +00:00
assert self.media_item.select_book_combo_box.currentData.called is False
2016-12-18 14:01:05 +00:00
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()
2017-12-22 21:04:29 +00:00
assert mocked_combo_box.addItem.call_args_list == \
[call('10', 10), call('11', 11), call('12', 12), call('13', 13)]
2016-12-18 14:01:05 +00:00
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()
2017-12-22 21:04:29 +00:00
assert mocked_combo_box.addItem.call_args_list == \
2017-12-23 09:30:02 +00:00
[call('10', 10), call('11', 11), call('12', 12), call('13', 13)]
2016-12-18 14:01:05 +00:00
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()
2017-12-22 21:04:29 +00:00
assert mocked_combo_box.addItem.call_args_list == \
[call('10', 10), call('11', 11), call('12', 12), call('13', 13)]
2016-12-18 14:01:05 +00:00
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
2017-12-22 21:04:29 +00:00
assert self.mocked_main_window.information_message.call_count == 1
2016-12-18 14:01:05 +00:00
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
2017-12-22 21:04:29 +00:00
assert self.mocked_plugin.manager.get_verses.call_count == 1
2016-12-18 14:01:05 +00:00
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
2017-12-22 21:04:29 +00:00
assert self.mocked_plugin.manager.get_verses.call_count == 2
2016-12-18 14:01:05 +00:00
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
2017-12-22 21:04:29 +00:00
assert self.mocked_plugin.manager.get_verses.call_count == 1
2016-12-18 14:01:05 +00:00
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
2017-12-22 21:04:29 +00:00
assert self.mocked_plugin.manager.get_verses.call_count == 1
2016-12-18 14:01:05 +00:00
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
2017-12-22 21:04:29 +00:00
assert self.mocked_plugin.manager.get_verses.call_count == 2
2016-12-18 14:01:05 +00:00
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
2017-12-22 21:04:29 +00:00
assert self.media_item.search_results == ['results', 'list']
2016-12-18 14:01:05 +00:00
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
2017-12-22 21:04:29 +00:00
assert self.media_item.search_results == []
2016-12-18 14:01:05 +00:00
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
2017-12-22 21:04:29 +00:00
assert self.media_item.search_results == [mocked_verse_1, mocked_verse_2]
assert self.media_item.second_search_results == [mocked_verse_1a, mocked_verse_2a]
assert self.mocked_log.debug.called is False
assert self.mocked_main_window.information_message.called is False
2016-12-18 14:01:05 +00:00
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
2017-12-22 21:04:29 +00:00
assert self.media_item.search_results == [mocked_verse_1]
assert self.media_item.second_search_results == [mocked_verse_1a]
assert self.mocked_log.debug.call_count == 2
2017-12-22 22:20:04 +00:00
assert self.mocked_main_window.information_message.called is True
2016-12-18 14:01:05 +00:00
mocked_display_results.assert_called_once_with()
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
2017-12-22 22:20:04 +00:00
assert self.media_item.search_timer.isActive.called is False
2016-12-18 14:01:05 +00:00
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
2017-06-03 22:34:19 +00:00
self.media_item.bible = self.mocked_bible_1
self.media_item.bible.is_web_bible = False
2016-12-18 14:01:05 +00:00
# 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
2017-12-22 21:04:29 +00:00
assert self.media_item.search_status == SearchStatus.SearchAsYouType
mocked_text_search.assert_called_once_with()
2016-12-18 14:01:05 +00:00
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
2017-12-22 22:20:04 +00:00
assert self.media_item.list_view.addItem.called is False
2016-12-18 14:01:05 +00:00
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:
2016-12-18 14:01:05 +00:00
self.media_item.search_results = ['results']
self.media_item.list_view = MagicMock()
2016-12-18 14:01:05 +00:00
# WHEN: Calling display_results
self.media_item.display_results()
2016-12-18 14:01:05 +00:00
# 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'}])