def setUp(self):
     self.se = SearchEngine("test_db")
     self.se.db.update(DB)
     with open("test.txt", 'w') as f:
         f.write(TEST)
     with open("test1.txt", 'w') as f:
         f.write(TEST1)
     with open("test3.txt", 'w') as f:
         f.write(TEST3)
     # a
     self.search_result1 = {'test.txt': [Position(0, 8, 9)]}
     # бобы
     self.search_result2 = {
         'test3.txt': [
             Position(0, 19, 23),
             Position(0, 31, 35),
             Position(0, 38, 42),
             Position(0, 61, 65),
             Position(0, 76, 80)
         ]
     }
     # to test
     self.search_result3 = {
         'test.txt':
         [Position(0, 10, 14),
          Position(1, 6, 8),
          Position(1, 9, 13)],
         'test1.txt': [Position(0, 13, 15),
                       Position(0, 16, 20)]
     }
class MultiwordSearchTest(unittest.TestCase):
    """
    Tests method multiword_search of SearchEngine.
    """
    def setUp(self):
        self.se = SearchEngine("test_db")
        self.se.db.update(DB)

    def test_wrong_input_error(self):
        with self.assertRaises(ValueError):
            self.se.multiword_search(123)

    def test_empty_input(self):
        result = self.se.multiword_search("")
        self.assertEqual(result, {})

    def test_no_alph_or_num_in_input(self):
        result = self.se.multiword_search("!!!")
        self.assertEqual(result, {})

    def test_absent_key(self):
        result = self.se.multiword_search("turtle test")
        self.assertEqual(result, {})

    def test_adjacent_words(self):
        result = self.se.multiword_search("to test")
        self.assertEqual(
            result, {
                'test.txt':
                [Position(0, 10, 14),
                 Position(1, 6, 8),
                 Position(1, 9, 13)],
                'test1.txt': [Position(0, 13, 15),
                              Position(0, 16, 20)]
            })

    def test_far_words(self):
        result = self.se.multiword_search("cat animals")
        self.assertEqual(
            result, {'test2.txt': [Position(0, 0, 3),
                                   Position(5, 10, 17)]})

    def tearDown(self):
        del self.se
        for filename in os.listdir('.'):
            if filename.startswith("test_db."):
                os.remove(filename)
class SimpleSearchTest(unittest.TestCase):
    """
    Tests method simple_search of class SearchEngine
    """
    def setUp(self):
        self.se = SearchEngine("test_db")
        self.se.db.update(DB)

    def test_wrong_input_error(self):
        with self.assertRaises(ValueError):
            self.se.simple_search(123)

    def test_empty_input(self):
        result = self.se.simple_search("")
        self.assertEqual(result, {})

    def test_no_alph_or_num_in_input(self):
        result = self.se.simple_search("!!!")
        self.assertEqual(result, {})

    def test_absent_key(self):
        result = self.se.simple_search("turtle")
        self.assertEqual(result, {})

    def test_actual_key(self):
        result = self.se.simple_search("test")
        self.assertIsInstance(result, dict)
        self.assertEqual(
            result, {
                "test.txt": [Position(0, 10, 14),
                             Position(1, 9, 13)],
                "test1.txt": [Position(0, 16, 20)]
            })

    def test_two_words_input(self):
        result = self.se.simple_search("test me")
        self.assertEqual(result, {})

    def tearDown(self):
        del self.se
        for filename in os.listdir('.'):
            if filename.startswith("test_db."):
                os.remove(filename)
 def setUp(self):
     self.se = SearchEngine("test_db")
     self.se.db.update(DB)
     with open("test3.txt", 'w') as f:
         f.write(TEST3)
class WindowToQuoteTest(unittest.TestCase):
    """
    Tests method cut_and_highlight of class Context and method search_to_quote
    of class SearchEngine.
    """
    def setUp(self):
        self.se = SearchEngine("test_db")
        self.se.db.update(DB)
        with open("test3.txt", 'w') as f:
            f.write(TEST3)

    def test_short_context(self):
        # engine +1
        context = Context([Position(0, 32, 38)], TEST1, 25, 38)
        result = context.cut_and_highlight()
        self.assertEqual(result, 'search <b>engine</b>')

    def test_whole_line(self):
        # Дурацкие вообще
        context = Context(
            [Position(0, 43, 49), Position(0, 67, 75)], TEST3, 0, 81)
        result = context.cut_and_highlight()
        ideal = 'Я не люблю красные бобы, белые бобы и бобы <b>вообще</b>. Противные бобы. <b>Дурацкие</b> бобы.'
        self.assertEqual(result, ideal)

    def test_part_of_line(self):
        #Я
        context = Context([Position(0, 0, 1)], TEST3, 0, 50)
        result = context.cut_and_highlight()
        ideal = '<b>Я</b> не люблю красные бобы, белые бобы и бобы вообще.'
        self.assertEqual(result, ideal)

    def test_many_words(self):
        #бобы
        context = Context([
            Position(0, 19, 23),
            Position(0, 31, 35),
            Position(0, 38, 42),
            Position(0, 61, 65),
            Position(0, 76, 80)
        ], TEST3, 0, 81)
        result = context.cut_and_highlight()
        ideal = "Я не люблю красные <b>бобы</b>, белые <b>бобы</b> и <b>бобы</b> вообще. Противные <b>бобы</b>. Дурацкие <b>бобы</b>."
        self.assertEqual(result, ideal)

    def test_search_to_quote(self):
        query = "Дурацкие вообще"
        result = self.se.search_to_quote(query)
        ideal = {
            'test3.txt': [
                'Я не люблю красные бобы, белые бобы и бобы <b>вообще</b>. Противные бобы. <b>Дурацкие</b> бобы.'
            ]
        }
        self.assertEqual(result, ideal)

    def test_search_to_quote_2(self):
        query = "Я Дурацкие"
        result = self.se.search_to_quote(query, 0)
        ideal = {
            'test3.txt': [
                "<b>Я</b> не люблю красные бобы, белые бобы и бобы вообще.",
                "<b>Дурацкие</b> бобы."
            ]
        }
        self.assertEqual(result, ideal)

    def test_search_to_quote_3(self):
        query = "красные бобы"
        result = self.se.search_to_quote(query)
        ideal = {
            'test3.txt': [
                "Я не люблю <b>красные</b> <b>бобы</b>, белые <b>бобы</b> и <b>бобы</b> вообще. Противные <b>бобы</b>. Дурацкие <b>бобы</b>."
            ]
        }
        self.assertEqual(result, ideal)

    def tearDown(self):
        del self.se
        for filename in os.listdir('.'):
            if filename.startswith("test_db."):
                os.remove(filename)
        os.remove("test3.txt")
class SentenceContextWindowTest(unittest.TestCase):
    """
    Tests method to_sentence of class Context and search_to_sentence of class
    Search Engine.
    """
    def setUp(self):
        self.se = SearchEngine("test_db")
        self.se.db.update(DB)
        with open("test3.txt", 'w') as f:
            f.write(TEST3)

    def test_middle_of_sentence(self):
        # бобы +1
        context = Context(
            [Position(0, 19, 23),
             Position(0, 31, 35),
             Position(0, 38, 42)], TEST3, 11, 49)
        context.to_sentence()
        ideal = Context(
            [Position(0, 19, 23),
             Position(0, 31, 35),
             Position(0, 38, 42)], TEST3, 0, 50)
        self.assertEqual(context, ideal)

    def test_end_of_sentence(self):
        #(Дурацкие) бобы +0
        context = Context([Position(0, 76, 80)], TEST3, 76, 80)
        context.to_sentence()
        ideal = Context([Position(0, 76, 80)], TEST3, 67, 81)
        self.assertEqual(context, ideal)

    def test_beginning_of_sentence(self):
        # Противные +0
        context = Context([Position(0, 51, 60)], TEST3, 51, 60)
        context.to_sentence()
        ideal = Context([Position(0, 51, 60)], TEST3, 51, 66)
        self.assertEqual(context, ideal)

    def test_beginning_of_the_line(self):
        # Я +2
        context = Context([Position(0, 0, 1)], TEST3, 0, 10)
        context.to_sentence()
        ideal = Context([Position(0, 0, 1)], TEST3, 0, 50)
        self.assertEqual(context, ideal)

    def test_end_of_the_line(self):
        # engine +1
        context = Context([Position(0, 32, 38)], TEST1, 25, 38)
        context.to_sentence()
        ideal = Context([Position(0, 32, 38)], TEST1, 0, 38)

    def test_join_two_contexts(self):
        # вообще Дурацкие
        input_dict = {
            'test3.txt': [
                Context([Position(0, 43, 49)], TEST3, 0, 66),
                Context([Position(0, 67, 75)], TEST3, 51, 81)
            ]
        }
        ideal = {
            'test3.txt': [
                Context([Position(0, 43, 49),
                         Position(0, 67, 75)], TEST3, 0, 81)
            ]
        }
        result = self.se.join_contexts(input_dict)
        self.assertEqual(result, ideal)

    def test_search_to_sentence(self):
        query = "Дурацкие вообще"
        result = self.se.search_to_sentence(query)
        ideal = {
            'test3.txt': [
                Context([Position(0, 43, 49),
                         Position(0, 67, 75)], TEST3, 0, 81)
            ]
        }
        self.assertEqual(result, ideal)

    def test_search_to_sentence_2(self):
        query = "Я Дурацкие"
        result = self.se.search_to_sentence(query, 0)
        ideal = {
            'test3.txt': [
                Context([Position(0, 0, 1)], TEST3, 0, 50),
                Context([Position(0, 67, 75)], TEST3, 67, 81)
            ]
        }
        self.assertEqual(result, ideal)

    def tearDown(self):
        del self.se
        for filename in os.listdir('.'):
            if filename.startswith("test_db."):
                os.remove(filename)
        os.remove("test3.txt")
class JoinContextWindowsTest(unittest.TestCase):
    """
    Tests method join of class ContextWindow and methods
    get_context_windows and search_to_context of class SearchEngine.
    """
    def setUp(self):
        self.se = SearchEngine("test_db")
        self.se.db.update(DB)
        with open("test.txt", 'w') as f:
            f.write(TEST)
        with open("test1.txt", 'w') as f:
            f.write(TEST1)
        with open("test3.txt", 'w') as f:
            f.write(TEST3)
        # a
        self.search_result1 = {'test.txt': [Position(0, 8, 9)]}
        # бобы
        self.search_result2 = {
            'test3.txt': [
                Position(0, 19, 23),
                Position(0, 31, 35),
                Position(0, 38, 42),
                Position(0, 61, 65),
                Position(0, 76, 80)
            ]
        }
        # to test
        self.search_result3 = {
            'test.txt':
            [Position(0, 10, 14),
             Position(1, 6, 8),
             Position(1, 9, 13)],
            'test1.txt': [Position(0, 13, 15),
                          Position(0, 16, 20)]
        }

    def test_wrong_input_error(self):
        with self.assertRaises(ValueError):
            self.se.get_context_windows(3, 3)

    def test_output_type(self):
        result = self.se.get_context_windows(self.search_result1, 1)
        self.assertIsInstance(result, dict)

    def test_empty_input(self):
        result = self.se.get_context_windows({}, 3)
        self.assertEqual(result, {})

    def test_zero_context(self):
        result = self.se.get_context_windows(self.search_result1, 0)
        ideal = {'test.txt': [Context([Position(0, 8, 9)], TEST[0:19], 8, 9)]}
        self.assertEqual(result, ideal)

    def test_two_words_intersection(self):
        result = self.se.get_context_windows(self.search_result3, 2)
        ideal = {
            'test.txt': [
                Context([Position(0, 10, 14)], TEST[0:19], 5, 19),
                Context(
                    [Position(1, 6, 8), Position(1, 9, 13)], TEST[20:], 0, 27)
            ],
            'test1.txt': [
                Context([Position(0, 13, 15),
                         Position(0, 16, 20)], TEST1, 0, 31)
            ]
        }
        self.assertEqual(result, ideal)

    def test_eq(self):
        a = Context([Position(0, 8, 9)], TEST[0:19], 8, 9)
        b = Context([Position(0, 8, 9)], TEST[0:19], 8, 9)
        self.assertEqual(a, b)

    def test_join(self):
        a = Context([Position(0, 13, 15)], TEST1, 0, 24)
        b = Context([Position(0, 16, 20)], TEST1, 0, 31)
        a.join(b)
        self.assertEqual(
            a, Context(
                [Position(0, 13, 15), Position(0, 16, 20)], TEST1, 0, 31))

    def test_join_equal_windoows(self):
        a = Context([Position(0, 13, 15)], TEST1, 0, 24)
        b = Context([Position(0, 13, 15)], TEST1, 0, 24)
        a.join(b)
        self.assertEqual(a, Context([Position(0, 13, 15)], TEST1, 0, 24))

    def test_isintersected_equal_sets(self):
        a = Context([Position(0, 13, 15)], TEST1, 0, 24)
        b = Context([Position(0, 13, 15)], TEST1, 0, 24)
        self.assertTrue(a.isintersected(b))

    def test_join_inclusion_sets(self):
        a = Context([Position(0, 13, 15)], TEST1, 0, 24)
        b = Context([Position(0, 13, 15)], TEST1, 3, 20)
        a.join(b)
        self.assertEqual(a, Context([Position(0, 13, 15)], TEST1, 0, 24))

    def test_search_to_context(self):
        result = self.se.search_to_context("to test")
        ideal = {
            'test.txt': [
                Context([Position(0, 10, 14)], TEST[:19], 0, 19),
                Context(
                    [Position(1, 6, 8), Position(1, 9, 13)], TEST[20:], 0, 27)
            ],
            'test1.txt': [
                Context([Position(0, 13, 15),
                         Position(0, 16, 20)], TEST1, 0, 38)
            ]
        }
        self.assertEqual(result, ideal)

    def tearDown(self):
        del self.se
        for filename in os.listdir('.'):
            if filename.startswith("test_db."):
                os.remove(filename)
        os.remove("test.txt")
        os.remove("test1.txt")
        os.remove("test3.txt")
 def setUp(self):
     self.se = SearchEngine("test_db")
     self.se.db.update(DB)