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

wagtail/search/tests/test_postgres_backend.py

@@ -1,210 +0,0 @@
-import unittest
-
-from django.db import connection
-from django.test import TestCase
-from django.test.utils import override_settings
-
-from wagtail.search.query import Phrase
-from wagtail.search.tests.test_backends import BackendTests
-from wagtail.test.search import models
-
-
-@unittest.skipUnless(
-    connection.vendor == "postgresql", "The current database is not PostgreSQL"
-)
-@override_settings(
-    WAGTAILSEARCH_BACKENDS={
-        "default": {
-            "BACKEND": "wagtail.search.backends.database.postgres.postgres",
-        }
-    }
-)
-class TestPostgresSearchBackend(BackendTests, TestCase):
-    backend_path = "wagtail.search.backends.database.postgres.postgres"
-
-    def test_weights(self):
-        from ..backends.database.postgres.weights import (
-            BOOSTS_WEIGHTS,
-            WEIGHTS_VALUES,
-            determine_boosts_weights,
-            get_weight,
-        )
-
-        self.assertListEqual(
-            BOOSTS_WEIGHTS, [(10, "A"), (2, "B"), (0.5, "C"), (0.25, "D")]
-        )
-        self.assertListEqual(WEIGHTS_VALUES, [0.025, 0.05, 0.2, 1.0])
-
-        self.assertEqual(get_weight(15), "A")
-        self.assertEqual(get_weight(10), "A")
-        self.assertEqual(get_weight(9.9), "B")
-        self.assertEqual(get_weight(2), "B")
-        self.assertEqual(get_weight(1.9), "C")
-        self.assertEqual(get_weight(0), "D")
-        self.assertEqual(get_weight(-1), "D")
-
-        self.assertListEqual(
-            determine_boosts_weights([1]), [(1, "A"), (0, "B"), (0, "C"), (0, "D")]
-        )
-        self.assertListEqual(
-            determine_boosts_weights([-1]), [(-1, "A"), (-1, "B"), (-1, "C"), (-1, "D")]
-        )
-        self.assertListEqual(
-            determine_boosts_weights([-1, 1, 2]),
-            [(2, "A"), (1, "B"), (-1, "C"), (-1, "D")],
-        )
-        self.assertListEqual(
-            determine_boosts_weights([0, 1, 2, 3]),
-            [(3, "A"), (2, "B"), (1, "C"), (0, "D")],
-        )
-        self.assertListEqual(
-            determine_boosts_weights([0, 0.25, 0.75, 1, 1.5]),
-            [(1.5, "A"), (1, "B"), (0.5, "C"), (0, "D")],
-        )
-        self.assertListEqual(
-            determine_boosts_weights([0, 1, 2, 3, 4, 5, 6]),
-            [(6, "A"), (4, "B"), (2, "C"), (0, "D")],
-        )
-        self.assertListEqual(
-            determine_boosts_weights([-2, -1, 0, 1, 2, 3, 4]),
-            [(4, "A"), (2, "B"), (0, "C"), (-2, "D")],
-        )
-
-    def test_search_tsquery_chars(self):
-        """
-        Checks that tsquery characters are correctly escaped
-        and do not generate a PostgreSQL syntax error.
-        """
-
-        # Simple quote should be escaped inside each tsquery term.
-        results = self.backend.search("L'amour piqué par une abeille", models.Book)
-        self.assertUnsortedListEqual([r.title for r in results], [])
-        results = self.backend.search("'starting quote", models.Book)
-        self.assertUnsortedListEqual([r.title for r in results], [])
-        results = self.backend.search("ending quote'", models.Book)
-        self.assertUnsortedListEqual([r.title for r in results], [])
-        results = self.backend.search("double quo''te", models.Book)
-        self.assertUnsortedListEqual([r.title for r in results], [])
-        results = self.backend.search("triple quo'''te", models.Book)
-        self.assertUnsortedListEqual([r.title for r in results], [])
-
-        # Now suffixes.
-        results = self.backend.search("Something:B", models.Book)
-        self.assertUnsortedListEqual([r.title for r in results], [])
-        results = self.backend.search("Something:*", models.Book)
-        self.assertUnsortedListEqual([r.title for r in results], [])
-        results = self.backend.search("Something:A*BCD", models.Book)
-        self.assertUnsortedListEqual([r.title for r in results], [])
-
-        # Now the AND operator.
-        results = self.backend.search("first & second", models.Book)
-        self.assertUnsortedListEqual([r.title for r in results], [])
-
-        # Now the OR operator.
-        results = self.backend.search("first | second", models.Book)
-        self.assertUnsortedListEqual([r.title for r in results], [])
-
-        # Now the NOT operator.
-        results = self.backend.search("first & !second", models.Book)
-        self.assertUnsortedListEqual([r.title for r in results], [])
-
-        # Now the phrase operator.
-        results = self.backend.search("first <-> second", models.Book)
-        self.assertUnsortedListEqual([r.title for r in results], [])
-
-    def test_autocomplete_tsquery_chars(self):
-        """
-        Checks that tsquery characters are correctly escaped
-        and do not generate a PostgreSQL syntax error.
-        """
-
-        # Simple quote should be escaped inside each tsquery term.
-        results = self.backend.autocomplete(
-            "L'amour piqué par une abeille", models.Book
-        )
-        self.assertUnsortedListEqual([r.title for r in results], [])
-        results = self.backend.autocomplete("'starting quote", models.Book)
-        self.assertUnsortedListEqual([r.title for r in results], [])
-        results = self.backend.autocomplete("ending quote'", models.Book)
-        self.assertUnsortedListEqual([r.title for r in results], [])
-        results = self.backend.autocomplete("double quo''te", models.Book)
-        self.assertUnsortedListEqual([r.title for r in results], [])
-        results = self.backend.autocomplete("triple quo'''te", models.Book)
-        self.assertUnsortedListEqual([r.title for r in results], [])
-
-        # Backslashes should be escaped inside each tsquery term.
-        results = self.backend.autocomplete("backslash\\", models.Book)
-        self.assertUnsortedListEqual([r.title for r in results], [])
-
-        # Now suffixes.
-        results = self.backend.autocomplete("Something:B", models.Book)
-        self.assertUnsortedListEqual([r.title for r in results], [])
-        results = self.backend.autocomplete("Something:*", models.Book)
-        self.assertUnsortedListEqual([r.title for r in results], [])
-        results = self.backend.autocomplete("Something:A*BCD", models.Book)
-        self.assertUnsortedListEqual([r.title for r in results], [])
-
-        # Now the AND operator.
-        results = self.backend.autocomplete("first & second", models.Book)
-        self.assertUnsortedListEqual([r.title for r in results], [])
-
-        # Now the OR operator.
-        results = self.backend.autocomplete("first | second", models.Book)
-        self.assertUnsortedListEqual([r.title for r in results], [])
-
-        # Now the NOT operator.
-        results = self.backend.autocomplete("first & !second", models.Book)
-        self.assertUnsortedListEqual([r.title for r in results], [])
-
-        # Now the phrase operator.
-        results = self.backend.autocomplete("first <-> second", models.Book)
-        self.assertUnsortedListEqual([r.title for r in results], [])
-
-
-@unittest.skipUnless(
-    connection.vendor == "postgresql", "The current database is not PostgreSQL"
-)
-@override_settings(
-    WAGTAILSEARCH_BACKENDS={
-        "default": {
-            "BACKEND": "wagtail.search.backends.database.postgres.postgres",
-            "SEARCH_CONFIG": "dutch",
-        }
-    }
-)
-class TestPostgresLanguageTextSearch(TestCase):
-    backend_path = "wagtail.search.backends.database.postgres.postgres"
-
-    def setUp(self):
-        # get search backend by backend_path
-        BackendTests.setUp(self)
-
-        book = models.Book.objects.create(
-            title="Nu is beter dan nooit",
-            publication_date="1999-05-01",
-            number_of_pages=333,
-        )
-        self.backend.add(book)
-        self.book = book
-
-    def test_search_language_plain_text(self):
-        results = self.backend.search("Nu is beter dan nooit", models.Book)
-        self.assertEqual(list(results), [self.book])
-
-        results = self.backend.search("is beter", models.Book)
-        self.assertEqual(list(results), [self.book])
-
-        # search deals even with variations
-        results = self.backend.search("zijn beter", models.Book)
-        self.assertEqual(list(results), [self.book])
-
-        # search deals even when there are minor typos
-        results = self.backend.search("zij beter dan", models.Book)
-        self.assertEqual(list(results), [self.book])
-
-    def test_search_language_phrase_text(self):
-        results = self.backend.search(Phrase("Nu is beter"), models.Book)
-        self.assertEqual(list(results), [self.book])
-
-        results = self.backend.search(Phrase("Nu zijn beter"), models.Book)
-        self.assertEqual(list(results), [self.book])

wagtail/search/tests/test_queries.py

@@ -1,332 +0,0 @@
-from django.test import SimpleTestCase, TestCase
-
-from wagtail.search.query import And, Or, Phrase, PlainText
-from wagtail.search.utils import (
-    balanced_reduce,
-    normalise_query_string,
-    parse_query_string,
-    separate_filters_from_query,
-)
-
-
-class TestQueryStringNormalisation(TestCase):
-    def test_truncation(self):
-        test_querystring = "a" * 1000
-        result = normalise_query_string(test_querystring)
-        self.assertEqual(len(result), 255)
-
-    def test_no_truncation(self):
-        test_querystring = "a" * 10
-        result = normalise_query_string(test_querystring)
-        self.assertEqual(len(result), 10)
-
-
-class TestSeparateFiltersFromQuery(SimpleTestCase):
-    def test_only_query(self):
-        filters, query = separate_filters_from_query("hello world")
-
-        self.assertDictEqual(filters.dict(), {})
-        self.assertEqual(query, "hello world")
-
-    def test_filter(self):
-        filters, query = separate_filters_from_query("author:foo")
-
-        self.assertDictEqual(filters.dict(), {"author": "foo"})
-        self.assertEqual(query, "")
-
-    def test_filter_with_quotation_mark(self):
-        filters, query = separate_filters_from_query('author:"foo bar"')
-
-        self.assertDictEqual(filters.dict(), {"author": "foo bar"})
-        self.assertEqual(query, "")
-
-    def test_filter_and_query(self):
-        filters, query = separate_filters_from_query("author:foo hello world")
-
-        self.assertDictEqual(filters.dict(), {"author": "foo"})
-        self.assertEqual(query, "hello world")
-
-    def test_filter_with_quotation_mark_and_query(self):
-        filters, query = separate_filters_from_query('author:"foo bar" hello world')
-
-        self.assertDictEqual(filters.dict(), {"author": "foo bar"})
-        self.assertEqual(query, "hello world")
-
-    def test_filter_with_unclosed_quotation_mark_and_query(self):
-        filters, query = separate_filters_from_query('author:"foo bar hello world')
-
-        self.assertDictEqual(filters.dict(), {})
-        self.assertEqual(query, 'author:"foo bar hello world')
-
-    def test_two_filters_and_query(self):
-        filters, query = separate_filters_from_query(
-            'author:"foo bar" hello world bar:beer'
-        )
-
-        self.assertDictEqual(filters.dict(), {"author": "foo bar", "bar": "beer"})
-        self.assertEqual(query, "hello world")
-
-    def test_two_filters_with_quotation_marks_and_query(self):
-        filters, query = separate_filters_from_query(
-            'author:"foo bar" hello world bar:"two beers"'
-        )
-
-        self.assertDictEqual(filters.dict(), {"author": "foo bar", "bar": "two beers"})
-        self.assertEqual(query, "hello world")
-
-        filters, query = separate_filters_from_query(
-            "author:'foo bar' hello world bar:'two beers'"
-        )
-
-        self.assertDictEqual(filters.dict(), {"author": "foo bar", "bar": "two beers"})
-        self.assertEqual(query, "hello world")
-
-    def test_return_list_of_multiple_instances_for_same_filter_key(self):
-        filters, query = separate_filters_from_query(
-            'foo:test1 hello world foo:test2 foo:"test3" foo2:test4'
-        )
-
-        self.assertDictEqual(filters.dict(), {"foo": "test3", "foo2": "test4"})
-        self.assertListEqual(filters.getlist("foo"), ["test1", "test2", "test3"])
-        self.assertEqual(query, "hello world")
-
-
-class TestParseQueryString(SimpleTestCase):
-    def test_simple_query(self):
-        filters, query = parse_query_string("hello world")
-
-        self.assertDictEqual(filters.dict(), {})
-        self.assertEqual(repr(query), repr(PlainText("hello world")))
-
-    def test_with_phrase(self):
-        filters, query = parse_query_string('"hello world"')
-
-        self.assertDictEqual(filters.dict(), {})
-        self.assertEqual(repr(query), repr(Phrase("hello world")))
-
-        filters, query = parse_query_string("'hello world'")
-
-        self.assertDictEqual(filters.dict(), {})
-        self.assertEqual(repr(query), repr(Phrase("hello world")))
-
-    def test_with_simple_and_phrase(self):
-        filters, query = parse_query_string('this is simple "hello world"')
-
-        self.assertDictEqual(filters.dict(), {})
-        self.assertEqual(
-            repr(query), repr(And([PlainText("this is simple"), Phrase("hello world")]))
-        )
-
-        filters, query = parse_query_string("this is simple 'hello world'")
-
-        self.assertDictEqual(filters.dict(), {})
-        self.assertEqual(
-            repr(query), repr(And([PlainText("this is simple"), Phrase("hello world")]))
-        )
-
-    def test_operator(self):
-        filters, query = parse_query_string(
-            'this is simple "hello world"', operator="or"
-        )
-
-        self.assertDictEqual(filters.dict(), {})
-        self.assertEqual(
-            repr(query),
-            repr(
-                Or([PlainText("this is simple", operator="or"), Phrase("hello world")])
-            ),
-        )
-
-        filters, query = parse_query_string(
-            "this is simple 'hello world'", operator="or"
-        )
-
-        self.assertDictEqual(filters.dict(), {})
-        self.assertEqual(
-            repr(query),
-            repr(
-                Or([PlainText("this is simple", operator="or"), Phrase("hello world")])
-            ),
-        )
-
-    def test_with_phrase_unclosed(self):
-        filters, query = parse_query_string('"hello world')
-
-        self.assertDictEqual(filters.dict(), {})
-        self.assertEqual(repr(query), repr(Phrase("hello world")))
-
-        filters, query = parse_query_string("'hello world")
-
-        self.assertDictEqual(filters.dict(), {})
-        self.assertEqual(repr(query), repr(Phrase("hello world")))
-
-    def test_phrase_with_filter(self):
-        filters, query = parse_query_string('"hello world" author:"foo bar" bar:beer')
-
-        self.assertDictEqual(filters.dict(), {"author": "foo bar", "bar": "beer"})
-        self.assertEqual(repr(query), repr(Phrase("hello world")))
-
-        filters, query = parse_query_string("'hello world' author:'foo bar' bar:beer")
-
-        self.assertDictEqual(filters.dict(), {"author": "foo bar", "bar": "beer"})
-        self.assertEqual(repr(query), repr(Phrase("hello world")))
-
-    def test_long_queries(self):
-        filters, query = parse_query_string("0" * 60_000)
-        self.assertEqual(filters.dict(), {})
-        self.assertEqual(repr(query), repr(PlainText("0" * 60_000)))
-
-        filters, _ = parse_query_string(f'{"a" * 60_000}:"foo bar"')
-        self.assertEqual(filters.dict(), {"a" * 60_000: "foo bar"})
-
-    def test_long_filter_value(self):
-        filters, _ = parse_query_string(f"foo:ba{'r' * 60_000}")
-        self.assertEqual(filters.dict(), {"foo": f"ba{'r' * 60_000}"})
-
-    def test_joined_filters(self):
-        filters, query = parse_query_string("foo:bar:baz")
-        self.assertEqual(filters.dict(), {"foo": "bar"})
-        self.assertEqual(repr(query), repr(PlainText(":baz")))
-
-        filters, query = parse_query_string("foo:'bar':baz")
-        self.assertEqual(filters.dict(), {"foo": "bar"})
-        self.assertEqual(repr(query), repr(PlainText(":baz")))
-
-        filters, query = parse_query_string("foo:'bar:baz'")
-        self.assertEqual(filters.dict(), {"foo": "bar:baz"})
-
-    def test_multiple_phrases(self):
-        filters, query = parse_query_string('"hello world" "hi earth"')
-
-        self.assertEqual(
-            repr(query), repr(And([Phrase("hello world"), Phrase("hi earth")]))
-        )
-
-        filters, query = parse_query_string("'hello world' 'hi earth'")
-
-        self.assertEqual(
-            repr(query), repr(And([Phrase("hello world"), Phrase("hi earth")]))
-        )
-
-    def test_mixed_phrases_with_filters(self):
-        filters, query = parse_query_string(
-            """"lord of the rings" army_1:"elves" army_2:'humans'"""
-        )
-
-        self.assertDictEqual(filters.dict(), {"army_1": "elves", "army_2": "humans"})
-        self.assertEqual(
-            repr(query),
-            repr(Phrase("lord of the rings")),
-        )
-
-
-class TestBalancedReduce(SimpleTestCase):
-    # For simple values, this should behave exactly the same as Pythons reduce()
-    # So I've copied its tests: https://github.com/python/cpython/blob/21cdb711e3b1975398c54141e519ead02670610e/Lib/test/test_functools.py#L771
-
-    def test_reduce(self):
-        class Squares:
-            def __init__(self, max):
-                self.max = max
-                self.sofar = []
-
-            def __len__(self):
-                return len(self.sofar)
-
-            def __getitem__(self, i):
-                if not 0 <= i < self.max:
-                    raise IndexError
-                n = len(self.sofar)
-                while n <= i:
-                    self.sofar.append(n * n)
-                    n += 1
-                return self.sofar[i]
-
-        def add(x, y):
-            return x + y
-
-        self.assertEqual(balanced_reduce(add, ["a", "b", "c"], ""), "abc")
-        self.assertEqual(
-            balanced_reduce(add, [["a", "c"], [], ["d", "w"]], []), ["a", "c", "d", "w"]
-        )
-        self.assertEqual(balanced_reduce(lambda x, y: x * y, range(2, 8), 1), 5040)
-        self.assertEqual(
-            balanced_reduce(lambda x, y: x * y, range(2, 21), 1), 2432902008176640000
-        )
-        self.assertEqual(balanced_reduce(add, Squares(10)), 285)
-        self.assertEqual(balanced_reduce(add, Squares(10), 0), 285)
-        self.assertEqual(balanced_reduce(add, Squares(0), 0), 0)
-        self.assertRaises(TypeError, balanced_reduce)
-        self.assertRaises(TypeError, balanced_reduce, 42, 42)
-        self.assertRaises(TypeError, balanced_reduce, 42, 42, 42)
-        self.assertEqual(
-            balanced_reduce(42, "1"), "1"
-        )  # func is never called with one item
-        self.assertEqual(
-            balanced_reduce(42, "", "1"), "1"
-        )  # func is never called with one item
-        self.assertRaises(TypeError, balanced_reduce, 42, (42, 42))
-        self.assertRaises(
-            TypeError, balanced_reduce, add, []
-        )  # arg 2 must not be empty sequence with no initial value
-        self.assertRaises(TypeError, balanced_reduce, add, "")
-        self.assertRaises(TypeError, balanced_reduce, add, ())
-        self.assertRaises(TypeError, balanced_reduce, add, object())
-
-        class TestFailingIter:
-            def __iter__(self):
-                raise RuntimeError
-
-        self.assertRaises(RuntimeError, balanced_reduce, add, TestFailingIter())
-
-        self.assertIsNone(balanced_reduce(add, [], None))
-        self.assertEqual(balanced_reduce(add, [], 42), 42)
-
-        class BadSeq:
-            def __getitem__(self, index):
-                raise ValueError
-
-        self.assertRaises(ValueError, balanced_reduce, 42, BadSeq())
-
-    # Test reduce()'s use of iterators.
-    def test_iterator_usage(self):
-        class SequenceClass:
-            def __init__(self, n):
-                self.n = n
-
-            def __getitem__(self, i):
-                if 0 <= i < self.n:
-                    return i
-                else:
-                    raise IndexError
-
-        from operator import add
-
-        self.assertEqual(balanced_reduce(add, SequenceClass(5)), 10)
-        self.assertEqual(balanced_reduce(add, SequenceClass(5), 42), 52)
-        self.assertRaises(TypeError, balanced_reduce, add, SequenceClass(0))
-        self.assertEqual(balanced_reduce(add, SequenceClass(0), 42), 42)
-        self.assertEqual(balanced_reduce(add, SequenceClass(1)), 0)
-        self.assertEqual(balanced_reduce(add, SequenceClass(1), 42), 42)
-
-        d = {"one": 1, "two": 2, "three": 3}
-        self.assertEqual(balanced_reduce(add, d), "".join(d.keys()))
-
-    # This test is specific to balanced_reduce
-    def test_is_balanced(self):
-        # Tests that balanced_reduce returns the object as a balanced tree
-        class CombinedNode:
-            def __init__(self, a, b):
-                self.a = a
-                self.b = b
-
-            def __repr__(self):
-                return f"({self.a} {self.b})"
-
-        self.assertEqual(
-            repr(
-                balanced_reduce(CombinedNode, ["A", "B", "C", "D", "E", "F", "G", "H"])
-            ),
-            "(((A B) (C D)) ((E F) (G H)))",
-            # Note: functools.reduce will return '(((((((A B) C) D) E) F) G) H)'
-        )

wagtail/search/tests/test_related_fields.py

@@ -1,102 +0,0 @@
-from django.test import TestCase
-
-from wagtail.search import index
-from wagtail.test.search.models import Book, Novel
-from wagtail.test.testapp.models import Advert, ManyToManyBlogPage
-
-
-class TestSelectOnQuerySet(TestCase):
-    def test_select_on_queryset_with_foreign_key(self):
-        fields = index.RelatedFields(
-            "protagonist",
-            [
-                index.SearchField("name"),
-            ],
-        )
-
-        queryset = fields.select_on_queryset(Novel.objects.all())
-
-        # ForeignKey should be select_related
-        self.assertFalse(queryset._prefetch_related_lookups)
-        self.assertIn("protagonist", queryset.query.select_related)
-
-    def test_select_on_queryset_with_one_to_one(self):
-        fields = index.RelatedFields(
-            "book_ptr",
-            [
-                index.SearchField("title"),
-            ],
-        )
-
-        queryset = fields.select_on_queryset(Novel.objects.all())
-
-        # OneToOneField should be select_related
-        self.assertFalse(queryset._prefetch_related_lookups)
-        self.assertIn("book_ptr", queryset.query.select_related)
-
-    def test_select_on_queryset_with_many_to_many(self):
-        fields = index.RelatedFields(
-            "adverts",
-            [
-                index.SearchField("title"),
-            ],
-        )
-
-        queryset = fields.select_on_queryset(ManyToManyBlogPage.objects.all())
-
-        # ManyToManyField should be prefetch_related
-        self.assertIn("adverts", queryset._prefetch_related_lookups)
-        self.assertFalse(queryset.query.select_related)
-
-    def test_select_on_queryset_with_reverse_foreign_key(self):
-        fields = index.RelatedFields(
-            "categories", [index.RelatedFields("category", [index.SearchField("name")])]
-        )
-
-        queryset = fields.select_on_queryset(ManyToManyBlogPage.objects.all())
-
-        # reverse ForeignKey should be prefetch_related
-        self.assertIn("categories", queryset._prefetch_related_lookups)
-        self.assertFalse(queryset.query.select_related)
-
-    def test_select_on_queryset_with_reverse_one_to_one(self):
-        fields = index.RelatedFields(
-            "novel",
-            [
-                index.SearchField("subtitle"),
-            ],
-        )
-
-        queryset = fields.select_on_queryset(Book.objects.all())
-
-        # reverse OneToOneField should be select_related
-        self.assertFalse(queryset._prefetch_related_lookups)
-        self.assertIn("novel", queryset.query.select_related)
-
-    def test_select_on_queryset_with_reverse_many_to_many(self):
-        fields = index.RelatedFields(
-            "manytomanyblogpage",
-            [
-                index.SearchField("title"),
-            ],
-        )
-
-        queryset = fields.select_on_queryset(Advert.objects.all())
-
-        # reverse ManyToManyField should be prefetch_related
-        self.assertIn("manytomanyblogpage", queryset._prefetch_related_lookups)
-        self.assertFalse(queryset.query.select_related)
-
-    def test_select_on_queryset_with_taggable_manager(self):
-        fields = index.RelatedFields(
-            "tags",
-            [
-                index.SearchField("name"),
-            ],
-        )
-
-        queryset = fields.select_on_queryset(Novel.objects.all())
-
-        # Tags should be prefetch_related
-        self.assertIn("tags", queryset._prefetch_related_lookups)
-        self.assertFalse(queryset.query.select_related)

wagtail/search/tests/test_sqlite_backend.py

@@ -1,52 +0,0 @@
-import sqlite3
-import unittest
-from unittest import skip
-
-from django.db import connection
-from django.test.testcases import TestCase
-from django.test.utils import override_settings
-
-from wagtail.search.backends.database.sqlite.utils import fts5_available
-from wagtail.search.tests.test_backends import BackendTests
-
-
-@unittest.skipUnless(
-    connection.vendor == "sqlite", "The current database is not SQLite"
-)
-@unittest.skipIf(
-    sqlite3.sqlite_version_info < (3, 19, 0), "This SQLite version is not supported"
-)
-@unittest.skipUnless(fts5_available(), "The SQLite fts5 extension is not available")
-@override_settings(
-    WAGTAILSEARCH_BACKENDS={
-        "default": {
-            "BACKEND": "wagtail.search.backends.database.sqlite.sqlite",
-        }
-    }
-)
-class TestSQLiteSearchBackend(BackendTests, TestCase):
-    backend_path = "wagtail.search.backends.database.sqlite.sqlite"
-
-    @skip("The SQLite backend doesn't support boosting.")
-    def test_search_boosting_on_related_fields(self):
-        return super().test_search_boosting_on_related_fields()
-
-    @skip("The SQLite backend doesn't support boosting.")
-    def test_boost(self):
-        return super().test_boost()
-
-    @skip("The SQLite backend doesn't score annotations.")
-    def test_annotate_score(self):
-        return super().test_annotate_score()
-
-    @skip("The SQLite backend doesn't score annotations.")
-    def test_annotate_score_with_slice(self):
-        return super().test_annotate_score_with_slice()
-
-    @skip("The SQLite backend doesn't support searching on specified fields.")
-    def test_autocomplete_with_fields_arg(self):
-        return super().test_autocomplete_with_fields_arg()
-
-    @skip("The SQLite backend doesn't guarantee correct ranking of results.")
-    def test_ranking(self):
-        return super().test_ranking()