Improve coverage.

Author: WaVEV

django_mongodb_backend/expressions/search.py

@@ -930,7 +930,7 @@ def __init__(
         super().__init__()
 
     def __invert__(self):
-        return ValueError("SearchVector cannot be negated")
+        raise NotSupportedError("SearchVector cannot be negated")
 
     def __and__(self, other):
         raise NotSupportedError("SearchVector cannot be combined")

tests/atlas_search_/test_search.py

@@ -221,13 +221,13 @@ def test_search_autocomplete(self):
                 fuzzy={"maxEdits": 2},
             )
         )
-        self.assertCountEqual(qs.all, [self.article])
+        self.assertCountEqual(qs, [self.article])
 
     def test_search_autocomplete_embedded_model(self):
         qs = Article.objects.annotate(
             score=SearchAutocomplete(path="writer__name", query="Joselina")
         )
-        self.assertCountEqual(qs.all, [self.article])
+        self.assertCountEqual(qs, [self.article])
 
     def test_constant_score(self):
         constant_score = SearchScoreOption({"constant": {"value": 10}})
@@ -240,7 +240,7 @@ def test_constant_score(self):
                 score=constant_score,
             )
         )
-        self.assertCountEqual(qs.all, [self.article])
+        self.assertCountEqual(qs, [self.article])
         scored = qs.first()
         self.assertAlmostEqual(scored.score, 10.0, places=2)
 
@@ -268,12 +268,12 @@ def setUp(self):
 
     def test_search_exists(self):
         qs = Article.objects.annotate(score=SearchExists(path="body"))
-        self.assertCountEqual(qs.all, [self.article])
+        self.assertCountEqual(qs, [self.article])
 
     def test_constant_score(self):
         constant_score = SearchScoreOption({"constant": {"value": 10}})
         qs = Article.objects.annotate(score=SearchExists(path="body", score=constant_score))
-        self.assertCountEqual(qs.all, [self.article])
+        self.assertCountEqual(qs, [self.article])
         scored = qs.first()
         self.assertAlmostEqual(scored.score, 10.0, places=2)
 
@@ -298,14 +298,14 @@ def setUp(self):
 
     def test_search_in(self):
         qs = Article.objects.annotate(score=SearchIn(path="headline", value=["cross", "river"]))
-        self.assertCountEqual(qs.all, [self.article])
+        self.assertCountEqual(qs, [self.article])
 
     def test_constant_score(self):
         constant_score = SearchScoreOption({"constant": {"value": 10}})
         qs = Article.objects.annotate(
             score=SearchIn(path="headline", value=["cross", "river"], score=constant_score)
         )
-        self.assertCountEqual(qs.all, [self.article])
+        self.assertCountEqual(qs, [self.article])
         scored = qs.first()
         self.assertAlmostEqual(scored.score, 10.0, places=2)
 
@@ -333,15 +333,15 @@ def setUp(self):
         Article.objects.create(headline="cheetah", number=2, body="fastest animal")
 
     def test_search_phrase(self):
-        qs = Article.objects.annotate(score=SearchPhrase(path="body", query="quick brown"))
-        self.assertCountEqual(qs.all, [self.article])
+        qs = Article.objects.annotate(score=SearchPhrase(path="body", query="quick brown", slop=3))
+        self.assertCountEqual(qs, [self.article])
 
     def test_constant_score(self):
         constant_score = SearchScoreOption({"constant": {"value": 10}})
         qs = Article.objects.annotate(
             score=SearchPhrase(path="body", query="quick brown", score=constant_score)
         )
-        self.assertCountEqual(qs.all, [self.article])
+        self.assertCountEqual(qs, [self.article])
         scored = qs.first()
         self.assertAlmostEqual(scored.score, 10.0, places=2)
 
@@ -432,14 +432,16 @@ def setUp(self):
 
     def test_search_range(self):
         qs = Article.objects.annotate(score=SearchRange(path="number", gte=10, lt=30))
-        self.assertCountEqual(qs.all, [self.number20])
+        self.assertCountEqual(qs, [self.number20])
+        qs = Article.objects.annotate(score=SearchRange(path="number", gt=20, lte=30))
+        self.assertCountEqual(qs, [])
 
     def test_constant_score(self):
         constant_score = SearchScoreOption({"constant": {"value": 10}})
         qs = Article.objects.annotate(
             score=SearchRange(path="number", gte=10, lt=30, score=constant_score)
         )
-        self.assertCountEqual(qs.all, [self.number20])
+        self.assertCountEqual(qs, [self.number20])
         scored = qs.first()
         self.assertAlmostEqual(scored.score, 10.0, places=2)
 
@@ -474,7 +476,7 @@ def test_search_regex(self):
         qs = Article.objects.annotate(
             score=SearchRegex(path="headline", query="hello.*", allow_analyzed_field=True)
         )
-        self.assertCountEqual(qs.all, [self.article])
+        self.assertCountEqual(qs, [self.article])
 
     def test_constant_score(self):
         constant_score = SearchScoreOption({"constant": {"value": 10}})
@@ -483,7 +485,7 @@ def test_constant_score(self):
                 path="headline", query="hello.*", allow_analyzed_field=True, score=constant_score
             )
         )
-        self.assertCountEqual(qs.all, [self.article])
+        self.assertCountEqual(qs, [self.article])
         scored = qs.first()
         self.assertAlmostEqual(scored.score, 10.0, places=2)
 
@@ -514,19 +516,19 @@ def setUp(self):
 
     def test_search_text(self):
         qs = Article.objects.annotate(score=SearchText(path="body", query="lazy"))
-        self.assertCountEqual(qs.all, [self.article])
+        self.assertCountEqual(qs, [self.article])
 
     def test_search_lookup(self):
         qs = Article.objects.filter(body__search="lazy")
-        self.assertCountEqual(qs.all, [self.article])
+        self.assertCountEqual(qs, [self.article])
 
     def test_search_text_with_fuzzy_and_criteria(self):
         qs = Article.objects.annotate(
             score=SearchText(
                 path="body", query="lazzy", fuzzy={"maxEdits": 2}, match_criteria="all"
             )
         )
-        self.assertCountEqual(qs.all, [self.article])
+        self.assertCountEqual(qs, [self.article])
 
     def test_constant_score(self):
         constant_score = SearchScoreOption({"constant": {"value": 10}})
@@ -539,7 +541,7 @@ def test_constant_score(self):
                 score=constant_score,
             )
         )
-        self.assertCountEqual(qs.all, [self.article])
+        self.assertCountEqual(qs, [self.article])
         scored = qs.first()
         self.assertAlmostEqual(scored.score, 10.0, places=2)
 
@@ -578,15 +580,17 @@ def setUp(self):
         Article.objects.create(headline="batman", number=2, body="")
 
     def test_search_wildcard(self):
-        qs = Article.objects.annotate(score=SearchWildcard(path="headline", query="dark-*"))
-        self.assertCountEqual(qs.all, [self.article])
+        qs = Article.objects.annotate(
+            score=SearchWildcard(path="headline", query="dark-*", allow_analyzed_field=False)
+        )
+        self.assertCountEqual(qs, [self.article])
 
     def test_constant_score(self):
         constant_score = SearchScoreOption({"constant": {"value": 10}})
         qs = Article.objects.annotate(
             score=SearchWildcard(path="headline", query="dark-*", score=constant_score)
         )
-        self.assertCountEqual(qs.all, [self.article])
+        self.assertCountEqual(qs, [self.article])
         scored = qs.first()
         self.assertAlmostEqual(scored.score, 10.0, places=2)
 
@@ -633,7 +637,7 @@ def test_search_geo_shape(self):
         qs = Article.objects.annotate(
             score=SearchGeoShape(path="location", relation="within", geometry=polygon)
         )
-        self.assertCountEqual(qs.all, [self.article])
+        self.assertCountEqual(qs, [self.article])
 
     def test_constant_score(self):
         polygon = {
@@ -646,7 +650,7 @@ def test_constant_score(self):
                 path="location", relation="within", geometry=polygon, score=constant_score
             )
         )
-        self.assertCountEqual(qs.all, [self.article])
+        self.assertCountEqual(qs, [self.article])
         scored = qs.first()
         self.assertAlmostEqual(scored.score, 10.0, places=2)
 
@@ -697,7 +701,7 @@ def test_search_geo_within(self):
                 geometry=polygon,
             )
         )
-        self.assertCountEqual(qs.all, [self.article])
+        self.assertCountEqual(qs, [self.article])
 
     def test_constant_score(self):
         polygon = {
@@ -713,7 +717,7 @@ def test_constant_score(self):
                 score=constant_score,
             )
         )
-        self.assertCountEqual(qs.all, [self.article])
+        self.assertCountEqual(qs, [self.article])
         scored = qs.first()
         self.assertAlmostEqual(scored.score, 10.0, places=2)
 
@@ -775,7 +779,7 @@ def test_search_more_like_this(self):
         qs = Article.objects.annotate(score=SearchMoreLikeThis(documents=like_docs)).order_by(
             "score"
         )
-        self.assertQuerySetEqual(qs.all, [self.article1, self.article2], lambda a: a.headline)
+        self.assertQuerySetEqual(qs, [self.article1, self.article2], lambda a: a.headline)
 
 
 class CompoundSearchTests(SearchUtilsMixin):
@@ -834,14 +838,14 @@ def test_expression(self):
         )
 
         qs = Article.objects.annotate(score=compound).order_by("score")
-        self.assertCountEqual(qs.all, [self.exoplanet])
+        self.assertCountEqual(qs, [self.exoplanet])
 
     def test_operations(self):
         expr = SearchEquals(path="headline", value="space exploration") & ~SearchEquals(
             path="number", value=3
         )
         qs = Article.objects.annotate(score=expr)
-        self.assertCountEqual(qs.all, [self.mars_mission, self.exoplanet])
+        self.assertCountEqual(qs, [self.mars_mission, self.exoplanet])
 
     def test_mixed_scores(self):
         boost_score = SearchScoreOption({"boost": {"value": 5}})
@@ -853,11 +857,13 @@ def test_mixed_scores(self):
         must_expr = SearchEquals(path="headline", value="space exploration", score=boost_score)
         should_expr = SearchPhrase(path="body", query="exoplanets", score=constant_score)
         must_not_expr = SearchPhrase(path="body", query="icy moons", score=function_score)
+        filter_ = SearchRange(path="number", gte=1, lt=4)
 
         compound = CompoundExpression(
             must=[must_expr],
             must_not=[must_not_expr],
             should=[should_expr],
+            filter=[filter_],
         )
         qs = Article.objects.annotate(score=compound).order_by("-score")
         self.assertListEqual(lambda: list(qs.all()), [self.exoplanet, self.mars_mission])
@@ -937,7 +943,7 @@ def test_multiple_vector_search(self):
 
     def test_search_and_filter(self):
         qs = Article.objects.filter(headline__search="space exploration", number__gt=2)
-        self.assertCountEqual(qs.all, [self.icy_moons])
+        self.assertCountEqual(qs, [self.icy_moons])
 
     def test_str_returns_expected_format(self):
         must_expr = SearchEquals(path="headline", value="space exploration")
@@ -1003,7 +1009,7 @@ def test_vector_search(self):
             limit=2,
         )
         qs = Article.objects.annotate(score=expr).order_by("-score")
-        self.assertCountEqual(qs.all, [self.mars, self.cooking])
+        self.assertCountEqual(qs, [self.mars, self.cooking])
 
     def test_str_returns_expected_format(self):
         vector_query = [0.1, 0.2, 0.3]

tests/expressions_/test_combinable_search_expression.py

@@ -1,9 +1,11 @@
+from django.db import NotSupportedError
 from django.test import SimpleTestCase
 
 from django_mongodb_backend.expressions.search import (
     CombinedSearchExpression,
     CompoundExpression,
     SearchEquals,
+    SearchVector,
 )
 
 
@@ -74,3 +76,17 @@ def test_combined_expression_long_right_tree(self):
         self.assertEqual(len(solved.should[1].must), 2)
         self.assertEqual(solved.should[1].must[0], solved_B)
         self.assertCountEqual(solved.should[1].must[1].should, [solved_C, solved_D])
+
+    def test_vector_search_not_combinable(self):
+        expr1 = SearchVector(path="headline", query_vector=[1, 2, 3], num_candidates=5, limit=2)
+        expr2 = SearchVector(path="headline", query_vector=[1, 2, 4], num_candidates=5, limit=2)
+        with self.assertRaisesMessage(NotSupportedError, "SearchVector cannot be combined"):
+            expr1 & expr2
+        with self.assertRaisesMessage(NotSupportedError, "SearchVector cannot be combined"):
+            1 & expr2
+        with self.assertRaisesMessage(NotSupportedError, "SearchVector cannot be combined"):
+            expr1 | expr2
+        with self.assertRaisesMessage(NotSupportedError, "SearchVector cannot be combined"):
+            1 | expr2
+        with self.assertRaisesMessage(NotSupportedError, "SearchVector cannot be negated"):
+            expr1 = ~expr1