wagtail 7.1.1__py3-none-any.whl → 7.2__py3-none-any.whl

wagtail/search/tests/test_elasticsearch8_backend.py

@@ -1,15 +0,0 @@
-import unittest
-
-from django.test import TestCase
-
-from .elasticsearch_common_tests import ElasticsearchCommonSearchBackendTests
-
-try:
-    from elasticsearch import VERSION as ELASTICSEARCH_VERSION
-except ImportError:
-    ELASTICSEARCH_VERSION = (0, 0, 0)
-
-
-@unittest.skipIf(ELASTICSEARCH_VERSION[0] != 8, "Elasticsearch 8 required")
-class TestElasticsearch8SearchBackend(ElasticsearchCommonSearchBackendTests, TestCase):
-    backend_path = "wagtail.search.backends.elasticsearch8"

wagtail/search/tests/test_index_functions.py

@@ -1,256 +0,0 @@
-from datetime import date
-from unittest import mock
-
-from django.test import TestCase, override_settings
-
-from wagtail.models import Page
-from wagtail.search import index
-from wagtail.test.search import models
-from wagtail.test.testapp.models import AdvertWithCustomUUIDPrimaryKey, SimplePage
-from wagtail.test.utils import WagtailTestUtils
-
-
-class TestGetIndexedInstance(TestCase):
-    fixtures = ["search"]
-
-    def test_gets_instance(self):
-        obj = models.Author.objects.get(id=1)
-
-        # Should just return the object
-        indexed_instance = index.get_indexed_instance(obj)
-        self.assertEqual(indexed_instance, obj)
-
-    def test_gets_specific_class(self):
-        obj = models.Novel.objects.get(id=1)
-
-        # Running the command with the parent class should find the specific class again
-        indexed_instance = index.get_indexed_instance(obj.book_ptr)
-        self.assertEqual(indexed_instance, obj)
-
-    def test_blocks_not_in_indexed_objects(self):
-        obj = models.Novel(
-            title="Don't index me!",
-            publication_date=date(2017, 10, 18),
-            number_of_pages=100,
-        )
-        obj.save()
-
-        # We've told it not to index anything with the title "Don't index me"
-        # get_indexed_instance should return None
-        indexed_instance = index.get_indexed_instance(obj.book_ptr)
-        self.assertIsNone(indexed_instance)
-
-
-@mock.patch("wagtail.search.tests.DummySearchBackend", create=True)
-@override_settings(
-    WAGTAILSEARCH_BACKENDS={
-        "default": {"BACKEND": "wagtail.search.tests.DummySearchBackend"}
-    }
-)
-class TestInsertOrUpdateObject(WagtailTestUtils, TestCase):
-    def test_inserts_object(self, backend):
-        obj = models.Book.objects.create(
-            title="Test", publication_date=date(2017, 10, 18), number_of_pages=100
-        )
-        backend().reset_mock()
-
-        index.insert_or_update_object(obj)
-
-        backend().add.assert_called_with(obj)
-
-    def test_doesnt_insert_unsaved_object(self, backend):
-        obj = models.Book(
-            title="Test", publication_date=date(2017, 10, 18), number_of_pages=100
-        )
-        backend().reset_mock()
-
-        index.insert_or_update_object(obj)
-
-        self.assertFalse(backend().add.mock_calls)
-
-    def test_converts_to_specific_page(self, backend):
-        root_page = Page.objects.get(id=1)
-        page = root_page.add_child(
-            instance=SimplePage(title="test", slug="test", content="test")
-        )
-
-        # Convert page into a generic "Page" object and add it into the index
-        unspecific_page = page.page_ptr
-
-        backend().reset_mock()
-
-        index.insert_or_update_object(unspecific_page)
-
-        # It should be automatically converted back to the specific version
-        backend().add.assert_called_with(page)
-
-    def test_catches_index_error(self, backend):
-        obj = models.Book.objects.create(
-            title="Test", publication_date=date(2017, 10, 18), number_of_pages=100
-        )
-
-        backend().add.side_effect = ValueError("Test")
-        backend().reset_mock()
-
-        with self.assertLogs("wagtail.search.index", level="ERROR") as cm:
-            index.insert_or_update_object(obj)
-
-        self.assertEqual(len(cm.output), 1)
-        self.assertIn(
-            "Exception raised while adding <Book: Test> into the 'default' search backend",
-            cm.output[0],
-        )
-        self.assertIn("Traceback (most recent call last):", cm.output[0])
-        self.assertIn("ValueError: Test", cm.output[0])
-
-
-@mock.patch("wagtail.search.tests.DummySearchBackend", create=True)
-@override_settings(
-    WAGTAILSEARCH_BACKENDS={
-        "default": {"BACKEND": "wagtail.search.tests.DummySearchBackend"}
-    }
-)
-class TestRemoveObject(WagtailTestUtils, TestCase):
-    def test_removes_object(self, backend):
-        obj = models.Book.objects.create(
-            title="Test", publication_date=date(2017, 10, 18), number_of_pages=100
-        )
-        backend().reset_mock()
-
-        index.remove_object(obj)
-
-        backend().delete.assert_called_with(obj)
-
-    def test_removes_unsaved_object(self, backend):
-        obj = models.Book(
-            title="Test", publication_date=date(2017, 10, 18), number_of_pages=100
-        )
-        backend().reset_mock()
-
-        index.remove_object(obj)
-
-        backend().delete.assert_called_with(obj)
-
-    def test_catches_index_error(self, backend):
-        obj = models.Book.objects.create(
-            title="Test", publication_date=date(2017, 10, 18), number_of_pages=100
-        )
-        backend().reset_mock()
-
-        backend().delete.side_effect = ValueError("Test")
-
-        with self.assertLogs("wagtail.search.index", level="ERROR") as cm:
-            index.remove_object(obj)
-
-        self.assertEqual(len(cm.output), 1)
-        self.assertIn(
-            "Exception raised while deleting <Book: Test> from the 'default' search backend",
-            cm.output[0],
-        )
-        self.assertIn("Traceback (most recent call last):", cm.output[0])
-        self.assertIn("ValueError: Test", cm.output[0])
-
-
-@mock.patch("wagtail.search.tests.DummySearchBackend", create=True)
-@override_settings(
-    WAGTAILSEARCH_BACKENDS={
-        "default": {"BACKEND": "wagtail.search.tests.DummySearchBackend"}
-    }
-)
-class TestSignalHandlers(WagtailTestUtils, TestCase):
-    def test_index_on_create(self, backend):
-        backend().reset_mock()
-        with self.captureOnCommitCallbacks(execute=True):
-            obj = models.Book.objects.create(
-                title="Test", publication_date=date(2017, 10, 18), number_of_pages=100
-            )
-        backend().add.assert_called_with(obj)
-
-    def test_index_on_create_with_uuid_primary_key(self, backend):
-        backend().reset_mock()
-        with self.captureOnCommitCallbacks(execute=True):
-            obj = AdvertWithCustomUUIDPrimaryKey.objects.create(text="Test")
-        backend().add.assert_called_with(obj)
-
-    def test_index_on_update(self, backend):
-        obj = models.Book.objects.create(
-            title="Test", publication_date=date(2017, 10, 18), number_of_pages=100
-        )
-
-        backend().reset_mock()
-        obj.title = "Updated test"
-        with self.captureOnCommitCallbacks(execute=True):
-            obj.save()
-
-        self.assertEqual(backend().add.call_count, 1)
-        indexed_object = backend().add.call_args[0][0]
-        self.assertEqual(indexed_object.title, "Updated test")
-
-    def test_index_on_update_with_uuid_primary_key(self, backend):
-        obj = AdvertWithCustomUUIDPrimaryKey.objects.create(text="Test")
-
-        backend().reset_mock()
-        obj.text = "Updated test"
-        with self.captureOnCommitCallbacks(execute=True):
-            obj.save()
-
-        self.assertEqual(backend().add.call_count, 1)
-        indexed_object = backend().add.call_args[0][0]
-        self.assertEqual(indexed_object.text, "Updated test")
-
-    def test_index_on_delete(self, backend):
-        obj = models.Book.objects.create(
-            title="Test", publication_date=date(2017, 10, 18), number_of_pages=100
-        )
-
-        backend().reset_mock()
-        with self.captureOnCommitCallbacks(execute=True):
-            obj.delete()
-        backend().delete.assert_called_with(obj)
-
-    def test_index_on_delete_with_uuid_primary_key(self, backend):
-        obj = AdvertWithCustomUUIDPrimaryKey.objects.create(text="Test")
-
-        backend().reset_mock()
-        with self.captureOnCommitCallbacks(execute=True):
-            obj.delete()
-        backend().delete.assert_called_with(obj)
-
-    def test_do_not_index_fields_omitted_from_update_fields(self, backend):
-        obj = models.Book.objects.create(
-            title="Test", publication_date=date(2017, 10, 18), number_of_pages=100
-        )
-
-        backend().reset_mock()
-        obj.title = "Updated test"
-        obj.publication_date = date(2001, 10, 19)
-        with self.captureOnCommitCallbacks(execute=True):
-            obj.save(update_fields=["title"])
-
-        self.assertEqual(backend().add.call_count, 1)
-        indexed_object = backend().add.call_args[0][0]
-        self.assertEqual(indexed_object.title, "Updated test")
-        self.assertEqual(indexed_object.publication_date, date(2017, 10, 18))
-
-
-@mock.patch("wagtail.search.tests.DummySearchBackend", create=True)
-@override_settings(
-    WAGTAILSEARCH_BACKENDS={
-        "default": {"BACKEND": "wagtail.search.tests.DummySearchBackend"}
-    }
-)
-class TestSignalHandlersSearchDisabled(TestCase, WagtailTestUtils):
-    def test_index_on_create_and_update(self, backend):
-        obj = models.UnindexedBook.objects.create(
-            title="Test", publication_date=date(2017, 10, 18), number_of_pages=100
-        )
-
-        self.assertEqual(backend().add.call_count, 0)
-        self.assertIsNone(backend().add.call_args)
-
-        backend().reset_mock()
-        obj.title = "Updated test"
-        obj.save()
-
-        self.assertEqual(backend().add.call_count, 0)
-        self.assertIsNone(backend().add.call_args)

wagtail/search/tests/test_indexed_class.py

@@ -1,157 +0,0 @@
-from contextlib import contextmanager
-
-from django.core import checks
-from django.test import TestCase
-
-from wagtail.models import Page
-from wagtail.search import index
-from wagtail.test.search import models
-from wagtail.test.testapp.models import (
-    TaggedChildPage,
-    TaggedGrandchildPage,
-    TaggedPage,
-)
-
-
-@contextmanager
-def patch_search_fields(model, new_search_fields):
-    """
-    A context manager to allow testing of different search_fields configurations
-    without permanently changing the models' search_fields.
-    """
-    old_search_fields = model.search_fields
-    model.search_fields = new_search_fields
-    yield
-    model.search_fields = old_search_fields
-
-
-class TestContentTypeNames(TestCase):
-    def test_base_content_type_name(self):
-        name = models.Novel.indexed_get_toplevel_content_type()
-        self.assertEqual(name, "searchtests_book")
-
-    def test_qualified_content_type_name(self):
-        name = models.Novel.indexed_get_content_type()
-        self.assertEqual(name, "searchtests_book_searchtests_novel")
-
-
-class TestSearchFields(TestCase):
-    def make_dummy_type(self, search_fields):
-        return type("DummyType", (index.Indexed,), {"search_fields": search_fields})
-
-    def get_checks_result(warning_id=None):
-        """Run Django checks on any with the 'search' tag used when registering the check"""
-        checks_result = checks.run_checks()
-        if warning_id:
-            return [warning for warning in checks_result if warning.id == warning_id]
-        return checks_result
-
-    def test_basic(self):
-        cls = self.make_dummy_type(
-            [
-                index.SearchField("test", boost=100),
-                index.FilterField("filter_test"),
-            ]
-        )
-
-        self.assertEqual(len(cls.get_search_fields()), 2)
-        self.assertEqual(len(cls.get_searchable_search_fields()), 1)
-        self.assertEqual(len(cls.get_filterable_search_fields()), 1)
-
-    def test_overriding(self):
-        # If there are two fields with the same type and name
-        # the last one should override all the previous ones. This ensures that the
-        # standard convention of:
-        #
-        #     class SpecificPageType(Page):
-        #         search_fields = Page.search_fields + [some_other_definitions]
-        #
-        # ...causes the definitions in some_other_definitions to override Page.search_fields
-        # as intended.
-        cls = self.make_dummy_type(
-            [
-                index.SearchField("test", boost=100),
-                index.SearchField("test"),
-            ]
-        )
-
-        self.assertEqual(len(cls.get_search_fields()), 1)
-        self.assertEqual(len(cls.get_searchable_search_fields()), 1)
-        self.assertEqual(len(cls.get_filterable_search_fields()), 0)
-
-        field = cls.get_search_fields()[0]
-        self.assertIsInstance(field, index.SearchField)
-
-        # Boost should be reset to the default if it's not specified by the override
-        self.assertIsNone(field.boost)
-
-    def test_different_field_types_dont_override(self):
-        # A search and filter field with the same name should be able to coexist
-        cls = self.make_dummy_type(
-            [
-                index.SearchField("test", boost=100),
-                index.FilterField("test"),
-            ]
-        )
-
-        self.assertEqual(len(cls.get_search_fields()), 2)
-        self.assertEqual(len(cls.get_searchable_search_fields()), 1)
-        self.assertEqual(len(cls.get_filterable_search_fields()), 1)
-
-    def test_checking_search_fields(self):
-        with patch_search_fields(
-            models.Book, models.Book.search_fields + [index.SearchField("foo")]
-        ):
-            expected_errors = [
-                checks.Warning(
-                    "Book.search_fields contains non-existent field 'foo'",
-                    obj=models.Book,
-                    id="wagtailsearch.W004",
-                )
-            ]
-            errors = models.Book.check()
-            self.assertEqual(errors, expected_errors)
-
-    def test_checking_core_page_fields_are_indexed(self):
-        """Run checks to ensure that when core page fields are missing we get a warning"""
-
-        # first confirm that errors show as TaggedPage (in test models) has no Page.search_fields
-        errors = [
-            error for error in checks.run_checks() if error.id == "wagtailsearch.W001"
-        ]
-
-        # should only ever get this warning on the sub-classes of the page model
-        self.assertEqual(
-            [TaggedPage, TaggedChildPage, TaggedGrandchildPage],
-            [error.obj for error in errors],
-        )
-
-        for error in errors:
-            self.assertEqual(
-                error.msg,
-                "Core Page fields missing in `search_fields`",
-            )
-            self.assertIn(
-                "Page model search fields `search_fields = Page.search_fields + [...]`",
-                error.hint,
-            )
-
-        # second check that we get no errors when setting up the models correctly
-        with patch_search_fields(
-            TaggedPage, Page.search_fields + TaggedPage.search_fields
-        ):
-            errors = [
-                error
-                for error in checks.run_checks()
-                if error.id == "wagtailsearch.W001"
-            ]
-            self.assertEqual([], errors)
-
-        # third check that we get no errors when disabling all model search
-        with patch_search_fields(TaggedPage, []):
-            errors = [
-                error
-                for error in checks.run_checks()
-                if error.id == "wagtailsearch.W001"
-            ]
-            self.assertEqual([], errors)

wagtail/search/tests/test_mysql_backend.py

@@ -1,192 +0,0 @@
-import unittest
-from unittest import skip
-
-from django.db import connection
-from django.test.testcases import TransactionTestCase
-from django.test.utils import override_settings
-
-from wagtail.search.query import Not, PlainText
-from wagtail.search.tests.test_backends import BackendTests
-from wagtail.test.search import models
-
-
-@unittest.skipUnless(connection.vendor == "mysql", "The current database is not MySQL")
-@override_settings(
-    WAGTAILSEARCH_BACKENDS={
-        "default": {
-            "BACKEND": "wagtail.search.backends.database.mysql.mysql",
-        }
-    }
-)
-class TestMySQLSearchBackend(BackendTests, TransactionTestCase):
-    backend_path = "wagtail.search.backends.database.mysql.mysql"
-
-    # Overrides parent method, because there's a slight difference in what the MySQL backend supports/accepts as search queries.
-    def test_not(self):
-        all_other_titles = {
-            "A Clash of Kings",
-            "A Game of Thrones",
-            "A Storm of Swords",
-            "Foundation",
-            "Learning Python",
-            "The Hobbit",
-            "The Two Towers",
-            "The Fellowship of the Ring",
-            "The Return of the King",
-            "The Rust Programming Language",
-            "Two Scoops of Django 1.11",
-            "Programming Rust",
-        }
-
-        results = self.backend.search(
-            Not(PlainText("javascript")), models.Book.objects.all()
-        )
-        self.assertSetEqual({r.title for r in results}, all_other_titles)
-
-        results = self.backend.search(
-            ~PlainText("javascript"), models.Book.objects.all()
-        )
-        self.assertSetEqual({r.title for r in results}, all_other_titles)
-
-        # Tests multiple words
-        results = self.backend.search(
-            ~PlainText("javascript the"), models.Book.objects.all()
-        )
-        # NOTE: The difference with the parent method is here. As we're querying NOT 'javascript the', all entries containing both words should be excluded, but MySQL doesn't index stopwords in FULLTEXT indexes by default, so the JavaScript books won't match the query, since the 'the' word is excluded from the index. Therefore, both books will get returned.
-        self.assertSetEqual(
-            {r.title for r in results},
-            all_other_titles
-            | {"JavaScript: The Definitive Guide", "JavaScript: The good parts"},
-        )
-
-        # Tests multiple words too, but this time the second word is not a stopword
-        results = self.backend.search(
-            ~PlainText("javascript parts"), models.Book.objects.all()
-        )
-        self.assertSetEqual(
-            {r.title for r in results},
-            all_other_titles | {"JavaScript: The Definitive Guide"},
-        )
-
-    def test_empty_search(self):
-        results = self.backend.search("", models.Book.objects.all())
-        self.assertSetEqual(
-            {r.title for r in results},
-            set(),
-        )
-
-        results = self.backend.search(" ", models.Book.objects.all())
-        self.assertSetEqual(
-            {r.title for r in results},
-            set(),
-        )
-
-        results = self.backend.search("*", models.Book.objects.all())
-        self.assertSetEqual(
-            {r.title for r in results},
-            set(),
-        )
-
-    def test_empty_autocomplete(self):
-        results = self.backend.autocomplete("", models.Book.objects.all())
-        self.assertSetEqual(
-            {r.title for r in results},
-            set(),
-        )
-
-        results = self.backend.autocomplete(" ", models.Book.objects.all())
-        self.assertSetEqual(
-            {r.title for r in results},
-            set(),
-        )
-
-        results = self.backend.autocomplete("*", models.Book.objects.all())
-        self.assertSetEqual(
-            {r.title for r in results},
-            set(),
-        )
-
-    def test_symbols_in_search_term(self):
-        # symbols as their own tokens should be ignored
-        results = self.backend.search("javascript @ parts", models.Book.objects.all())
-        self.assertSetEqual(
-            {r.title for r in results},
-            {"JavaScript: The good parts"},
-        )
-
-        results = self.backend.search("javascript parts @", models.Book.objects.all())
-        self.assertSetEqual(
-            {r.title for r in results},
-            {"JavaScript: The good parts"},
-        )
-
-        results = self.backend.search("@ javascript parts", models.Book.objects.all())
-        self.assertSetEqual(
-            {r.title for r in results},
-            {"JavaScript: The good parts"},
-        )
-
-        # tokens containing both symbols and alphanumerics should not be discarded
-        # or treated as equivalent to the same token without symbols
-        results = self.backend.search("java@script parts", models.Book.objects.all())
-        self.assertSetEqual(
-            {r.title for r in results},
-            set(),
-        )
-
-    def test_autocomplete_with_symbols(self):
-        # the * is not part of the autocomplete mechanism, but if someone includes it
-        # we want it to be gracefully ignored
-        results = self.backend.autocomplete("parts javasc*", models.Book.objects.all())
-        self.assertSetEqual(
-            {r.title for r in results},
-            {"JavaScript: The good parts"},
-        )
-
-    def test_lexeme_validation(self):
-        from wagtail.search.backends.database.mysql.query import Lexeme
-
-        with self.assertRaisesMessage(ValueError, "Lexeme value cannot be empty."):
-            Lexeme("")
-
-        Lexeme("hello")  # no error
-
-        with self.assertRaisesMessage(
-            ValueError,
-            "Lexeme value 'hello world' must consist of alphanumeric characters "
-            "and '_' only.",
-        ):
-            Lexeme("hello world")
-
-        with self.assertRaisesMessage(
-            ValueError,
-            "Lexeme value 'rimsky@korsakov' must consist of alphanumeric characters "
-            "and '_' only.",
-        ):
-            Lexeme("rimsky@korsakov")
-
-    @skip(
-        "The MySQL backend doesn't support choosing individual fields for the search, only (body, title) or (autocomplete) fields may be searched."
-    )
-    def test_search_on_individual_field(self):
-        return super().test_search_on_individual_field()
-
-    @skip("The MySQL backend doesn't support boosting.")
-    def test_search_boosting_on_related_fields(self):
-        return super().test_search_boosting_on_related_fields()
-
-    @skip("The MySQL backend doesn't support boosting.")
-    def test_boost(self):
-        return super().test_boost()
-
-    @skip("The MySQL backend doesn't score annotations.")
-    def test_annotate_score(self):
-        return super().test_annotate_score()
-
-    @skip("The MySQL backend doesn't score annotations.")
-    def test_annotate_score_with_slice(self):
-        return super().test_annotate_score_with_slice()
-
-    @skip("The MySQL backend doesn't guarantee correct ranking of results.")
-    def test_ranking(self):
-        return super().test_ranking()