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

# -*- 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 Bibles plugin.
"""
from unittest import TestCase

from openlp.plugins.bibles import lib
from openlp.plugins.bibles.lib import SearchResults, get_reference_match
from tests.functional import MagicMock, patch
from tests.helpers.testmixin import TestMixin


class TestLib(TestCase, TestMixin):
    """
    Test the functions in the :mod:`lib` module.
    """
    @patch('openlp.plugins.bibles.lib.update_reference_separators')
    def test_get_reference_separator(self, mocked_update_reference_separators):
        """
        Test the get_reference_separator method
        """
        # GIVEN: A list of expected separators and the lib module's constant is empty
        lib.REFERENCE_SEPARATORS = None
        separators = {'sep_r': '\\s*(?:e)\\s*', 'sep_e_default': 'end', 'sep_v_display': 'w', 'sep_l_display': 'r',
                      'sep_v_default': ':|v|V|verse|verses', 'sep_l': '\\s*(?:r)\\s*', 'sep_l_default': ',|and',
                      'sep_e': '\\s*(?:t)\\s*', 'sep_v': '\\s*(?:w)\\s*', 'sep_r_display': 'e', 'sep_r_default': '-|to'}

        def _update_side_effect():
            """
            Update the references after mocking out the method
            """
            lib.REFERENCE_SEPARATORS = separators

        mocked_update_reference_separators.side_effect = _update_side_effect

        # WHEN: Calling get_reference_separator
        for key, value in separators.items():
            _ = lib.get_reference_separator(key)

            # THEN: get_reference_separator should return the correct separator
            self.assertEqual(separators[key], value)
        mocked_update_reference_separators.assert_called_once_with()

    def test_reference_matched_full(self):
        """
        Test that the 'full' regex parses bible verse references correctly.
        """
        # GIVEN: Some test data which contains different references to parse, with the expected results.
        with patch('openlp.plugins.bibles.lib.Settings', return_value=MagicMock(**{'value.return_value': ''})):
            # The following test data tests with 222 variants when using the default 'separators'
            test_data = [
                # Input reference, book name, chapter + verse reference
                ('Psalm 23', 'Psalm', '23'),
                ('Psalm. 23', 'Psalm', '23'),
                ('Psalm 23{to}24', 'Psalm', '23-24'),
                ('Psalm 23{verse}1{to}2', 'Psalm', '23:1-2'),
                ('Psalm 23{verse}1{to}{end}', 'Psalm', '23:1-end'),
                ('Psalm 23{verse}1{to}2{_and}5{to}6', 'Psalm', '23:1-2,5-6'),
                ('Psalm 23{verse}1{to}2{_and}5{to}{end}', 'Psalm', '23:1-2,5-end'),
                ('Psalm 23{verse}1{to}2{_and}24{verse}1{to}3', 'Psalm', '23:1-2,24:1-3'),
                ('Psalm 23{verse}1{to}{end}{_and}24{verse}1{to}{end}', 'Psalm', '23:1-end,24:1-end'),
                ('Psalm 23{verse}1{to}24{verse}1', 'Psalm', '23:1-24:1'),
                ('Psalm 23{_and}24', 'Psalm', '23,24'),
                ('1 John 23', '1 John', '23'),
                ('1 John. 23', '1 John', '23'),
                ('1 John 23{to}24', '1 John', '23-24'),
                ('1 John 23{verse}1{to}2', '1 John', '23:1-2'),
                ('1 John 23{verse}1{to}{end}', '1 John', '23:1-end'),
                ('1 John 23{verse}1{to}2{_and}5{to}6', '1 John', '23:1-2,5-6'),
                ('1 John 23{verse}1{to}2{_and}5{to}{end}', '1 John', '23:1-2,5-end'),
                ('1 John 23{verse}1{to}2{_and}24{verse}1{to}3', '1 John', '23:1-2,24:1-3'),
                ('1 John 23{verse}1{to}{end}{_and}24{verse}1{to}{end}', '1 John', '23:1-end,24:1-end'),
                ('1 John 23{verse}1{to}24{verse}1', '1 John', '23:1-24:1'),
                ('1 John 23{_and}24', '1 John', '23,24')]

            full_reference_match = get_reference_match('full')
            for reference_text, book_result, ranges_result in test_data:
                to_separators = ['-', ' - ', 'to', ' to '] if '{to}' in reference_text else ['']
                verse_separators = [':', ' : ', 'v', ' v ', 'V', ' V ', 'verse', ' verse ', 'verses', ' verses '] \
                    if '{verse}' in reference_text else ['']
                and_separators = [',', ' , ', 'and', ' and '] if '{_and}' in reference_text else ['']
                end_separators = ['end', ' end '] if '{end}' in reference_text else ['']

                for to in to_separators:
                    for verse in verse_separators:
                        for _and in and_separators:
                            for end in end_separators:
                                reference_text = reference_text.format(to=to, verse=verse, _and=_and, end=end)

                                # WHEN: Attempting to parse the input string
                                match = full_reference_match.match(reference_text)

                                # THEN: A match should be returned, and the book and reference should match the
                                #       expected result
                                self.assertIsNotNone(match, '{text} should provide a match'.format(text=reference_text))
                                self.assertEqual(book_result, match.group('book'),
                                                 '{text} does not provide the expected result for the book group.'
                                                 .format(text=reference_text))
                                self.assertEqual(ranges_result, match.group('ranges'),
                                                 '{text} does not provide the expected result for the ranges group.'
                                                 .format(text=reference_text))

    def test_reference_matched_range(self):
        """
        Test that the 'range' regex parses bible verse references correctly.
        Note: This test takes in to account that the regex does not work quite as expected!
        see https://bugs.launchpad.net/openlp/+bug/1638620
        """
        # GIVEN: Some test data which contains different references to parse, with the expected results.
        with patch('openlp.plugins.bibles.lib.Settings', return_value=MagicMock(**{'value.return_value': ''})):
            # The following test data tests with 45 variants when using the default 'separators'
            test_data = [
                ('23', None, '23', None, None, None),
                ('23{to}24', None, '23', '-24', None, '24'),
                ('23{verse}1{to}2', '23', '1', '-2', None, '2'),
                ('23{verse}1{to}{end}', '23', '1', '-end', None, None),
                ('23{verse}1{to}24{verse}1', '23', '1', '-24:1', '24', '1')]
            full_reference_match = get_reference_match('range')
            for reference_text, from_chapter, from_verse, range_to, to_chapter, to_verse in test_data:
                to_separators = ['-', ' - ', 'to', ' to '] if '{to}' in reference_text else ['']
                verse_separators = [':', ' : ', 'v', ' v ', 'V', ' V ', 'verse', ' verse ', 'verses', ' verses '] \
                    if '{verse}' in reference_text else ['']
                and_separators = [',', ' , ', 'and', ' and '] if '{_and}' in reference_text else ['']
                end_separators = ['end', ' end '] if '{end}' in reference_text else ['']

                for to in to_separators:
                    for verse in verse_separators:
                        for _and in and_separators:
                            for end in end_separators:
                                reference_text = reference_text.format(to=to, verse=verse, _and=_and, end=end)

                                # WHEN: Attempting to parse the input string
                                match = full_reference_match.match(reference_text)

                                # THEN: A match should be returned, and the to/from chapter/verses should match as
                                #       expected
                                self.assertIsNotNone(match, '{text} should provide a match'.format(text=reference_text))
                                self.assertEqual(match.group('from_chapter'), from_chapter)
                                self.assertEqual(match.group('from_verse'), from_verse)
                                self.assertEqual(match.group('range_to'), range_to)
                                self.assertEqual(match.group('to_chapter'), to_chapter)
                                self.assertEqual(match.group('to_verse'), to_verse)

    def test_reference_matched_range_separator(self):
        # GIVEN: Some test data which contains different references to parse, with the expected results.
        with patch('openlp.plugins.bibles.lib.Settings', return_value=MagicMock(**{'value.return_value': ''})):
            # The following test data tests with 111 variants when using the default 'separators'
            # The regex for handling ranges is a bit screwy, see https://bugs.launchpad.net/openlp/+bug/1638620
            test_data = [
                ('23', ['23']),
                ('23{to}24', ['23-24']),
                ('23{verse}1{to}2', ['23:1-2']),
                ('23{verse}1{to}{end}', ['23:1-end']),
                ('23{verse}1{to}2{_and}5{to}6', ['23:1-2', '5-6']),
                ('23{verse}1{to}2{_and}5{to}{end}', ['23:1-2', '5-end']),
                ('23{verse}1{to}2{_and}24{verse}1{to}3', ['23:1-2', '24:1-3']),
                ('23{verse}1{to}{end}{_and}24{verse}1{to}{end}', ['23:1-end', '24:1-end']),
                ('23{verse}1{to}24{verse}1', ['23:1-24:1']),
                ('23,24', ['23', '24'])]
            full_reference_match = get_reference_match('range_separator')
            for reference_text, ranges in test_data:
                to_separators = ['-', ' - ', 'to', ' to '] if '{to}' in reference_text else ['']
                verse_separators = [':', ' : ', 'v', ' v ', 'V', ' V ', 'verse', ' verse ', 'verses', ' verses '] \
                    if '{verse}' in reference_text else ['']
                and_separators = [',', ' , ', 'and', ' and '] if '{_and}' in reference_text else ['']
                end_separators = ['end', ' end '] if '{end}' in reference_text else ['']

                for to in to_separators:
                    for verse in verse_separators:
                        for _and in and_separators:
                            for end in end_separators:
                                reference_text = reference_text.format(to=to, verse=verse, _and=_and, end=end)

                                # WHEN: Attempting to parse the input string
                                references = full_reference_match.split(reference_text)

                                # THEN: The list of references should be as the expected results
                                self.assertEqual(references, ranges)

    def test_search_results_creation(self):
        """
        Test the creation and construction of the SearchResults class
        """
        # GIVEN: A book, chapter and a verse list
        book = 'Genesis'
        chapter = 1
        verse_list = {
            1: 'In the beginning God created the heavens and the earth.',
            2: 'The earth was without form and void, and darkness was over the face of the deep. And the Spirit of '
               'God was hovering over the face of the waters.'
        }

        # WHEN: We create the search results object
        search_results = SearchResults(book, chapter, verse_list)

        # THEN: It should have a book, a chapter and a verse list
        self.assertIsNotNone(search_results, 'The search_results object should not be None')
        self.assertEqual(search_results.book, book, 'The book should be "Genesis"')
        self.assertEqual(search_results.chapter, chapter, 'The chapter should be 1')
        self.assertDictEqual(search_results.verse_list, verse_list, 'The verse lists should be identical')

    def test_search_results_has_verse_list(self):
        """
        Test that a SearchResults object with a valid verse list returns True when checking ``has_verse_list()``
        """
        # GIVEN: A valid SearchResults object with a proper verse list
        search_results = SearchResults('Genesis', 1, {1: 'In the beginning God created the heavens and the earth.'})

        # WHEN: We check that the SearchResults object has a verse list
        has_verse_list = search_results.has_verse_list()

        # THEN: It should be True
        self.assertTrue(has_verse_list, 'The SearchResults object should have a verse list')

    def test_search_results_has_no_verse_list(self):
        """
        Test that a SearchResults object with an empty verse list returns False when checking ``has_verse_list()``
        """
        # GIVEN: A valid SearchResults object with an empty verse list
        search_results = SearchResults('Genesis', 1, {})

        # WHEN: We check that the SearchResults object has a verse list
        has_verse_list = search_results.has_verse_list()

        # THEN: It should be False
        self.assertFalse(has_verse_list, 'The SearchResults object should have a verse list')