Add str unit tests

Author: WaVEV

tests/atlas_search_/test_search.py

@@ -31,7 +31,7 @@
 from .models import Article, Location, Writer
 
 
-def wait_until_index_ready(collection, index_name, timeout: float = 30, interval: float = 0.5):
+def wait_until_index_ready(collection, index_name, timeout: float = 5, interval: float = 0.5):
     start = monotonic()
     while monotonic() - start < timeout:
         indexes = list(collection.list_search_indexes())
@@ -42,7 +42,7 @@ def wait_until_index_ready(collection, index_name, timeout: float = 30, interval
     raise TimeoutError(f"Index {index_name} not ready after {timeout} seconds")
 
 
-def _delayed_assertion(timeout: float = 120, interval: float = 0.5):
+def _delayed_assertion(timeout: float = 4, interval: float = 0.5):
     def decorator(assert_func):
         @wraps(assert_func)
         def wrapper(self, fetch, *args, **kwargs):
@@ -72,6 +72,14 @@ def wrapper(self, fetch, *args, **kwargs):
 class SearchUtilsMixin(TransactionTestCase):
     available_apps = None
 
+    """
+    These assertions include a small delay to account for MongoDB Atlas Search's
+    eventual consistency and indexing latency. Data inserted into MongoDB is not
+    immediately available for $search queries because Atlas Search indexes are
+    updated asynchronously via change streams. While this is usually fast, delays
+    can occur due to replication lag, system load, index complexity, or a high
+    number of search indexes.
+    """
     assertCountEqual = _delayed_assertion(timeout=2)(TransactionTestCase.assertCountEqual)
     assertListEqual = _delayed_assertion(timeout=2)(TransactionTestCase.assertListEqual)
     assertQuerySetEqual = _delayed_assertion(timeout=2)(TransactionTestCase.assertQuerySetEqual)
@@ -153,6 +161,11 @@ def test_function_score(self):
         scored = qs.first()
         self.assertAlmostEqual(scored.score, 1.0, places=2)
 
+    def test_str_returns_expected_format(self):
+        score = SearchScoreOption({"constant": {"value": 10}})
+        se = SearchEquals(path="headline", value="cross", score=score)
+        self.assertEqual(str(se), f"<SearchEquals(path='headline', value='cross', score={score})>")
+
 
 class SearchAutocompleteTests(SearchUtilsMixin):
     @classmethod
@@ -232,6 +245,15 @@ def test_constant_score(self):
         scored = qs.first()
         self.assertAlmostEqual(scored.score, 10.0, places=2)
 
+    def test_str_returns_expected_format(self):
+        score = SearchScoreOption({"constant": {"value": 10}})
+        se = SearchAutocomplete(path="writer__name", query="Joselina", score=score)
+        self.assertEqual(
+            str(se),
+            "<SearchAutocomplete(path='writer__name', query='Joselina', fuzzy=None,"
+            f" token_order=None, score={score})>",
+        )
+
 
 class SearchExistsTests(SearchUtilsMixin):
     @classmethod
@@ -257,6 +279,11 @@ def test_constant_score(self):
         scored = qs.first()
         self.assertAlmostEqual(scored.score, 10.0, places=2)
 
+    def test_str_returns_expected_format(self):
+        score = SearchScoreOption({"constant": {"value": 10}})
+        se = SearchExists(path="body", score=score)
+        self.assertEqual(str(se), f"<SearchExists(path='body', score={score})>")
+
 
 class SearchInTests(SearchUtilsMixin):
     @classmethod
@@ -285,6 +312,13 @@ def test_constant_score(self):
         scored = qs.first()
         self.assertAlmostEqual(scored.score, 10.0, places=2)
 
+    def test_str_returns_expected_format(self):
+        score = SearchScoreOption({"constant": {"value": 10}})
+        se = SearchIn(path="headline", value=["cross", "river"], score=score)
+        self.assertEqual(
+            str(se), f"<SearchIn(path='headline', value=('cross', 'river'), score={score})>"
+        )
+
 
 class SearchPhraseTests(SearchUtilsMixin):
     @classmethod
@@ -315,6 +349,15 @@ def test_constant_score(self):
         scored = qs.first()
         self.assertAlmostEqual(scored.score, 10.0, places=2)
 
+    def test_str_returns_expected_format(self):
+        score = SearchScoreOption({"constant": {"value": 10}})
+        se = SearchPhrase(path="body", query="quick brown", score=score)
+        self.assertEqual(
+            str(se),
+            "<SearchPhrase(path='body', query='quick brown', slop=None, "
+            f"synonyms=None, score={score})>",
+        )
+
 
 class SearchRangeTests(SearchUtilsMixin):
     @classmethod
@@ -343,6 +386,14 @@ def test_constant_score(self):
         scored = qs.first()
         self.assertAlmostEqual(scored.score, 10.0, places=2)
 
+    def test_str_returns_expected_format(self):
+        score = SearchScoreOption({"constant": {"value": 10}})
+        se = SearchRange(path="number", gte=10, lt=30, score=score)
+        self.assertEqual(
+            str(se),
+            f"<SearchRange(path='number', lt=30, lte=None, gt=None, gte=10, score={score})>",
+        )
+
 
 class SearchRegexTests(SearchUtilsMixin):
     @classmethod
@@ -380,6 +431,15 @@ def test_constant_score(self):
         scored = qs.first()
         self.assertAlmostEqual(scored.score, 10.0, places=2)
 
+    def test_str_returns_expected_format(self):
+        score = SearchScoreOption({"constant": {"value": 10}})
+        se = SearchRegex(path="headline", query="hello.*", allow_analyzed_field=True, score=score)
+        self.assertEqual(
+            str(se),
+            "<SearchRegex(path='headline', query='hello.*', "
+            f"allow_analyzed_field=True, score={score})>",
+        )
+
 
 class SearchTextTests(SearchUtilsMixin):
     @classmethod
@@ -428,6 +488,21 @@ def test_constant_score(self):
         scored = qs.first()
         self.assertAlmostEqual(scored.score, 10.0, places=2)
 
+    def test_str_returns_expected_format(self):
+        score = SearchScoreOption({"constant": {"value": 10}})
+        se = SearchText(
+            path="body",
+            query="lazzy",
+            fuzzy={"maxEdits": 2},
+            match_criteria="all",
+            score=score,
+        )
+        self.assertEqual(
+            str(se),
+            "<SearchText(path='body', query='lazzy', fuzzy=(('maxEdits', 2),), "
+            f"match_criteria='all', synonyms=None, score={score})>",
+        )
+
 
 class SearchWildcardTests(SearchUtilsMixin):
     @classmethod
@@ -461,6 +536,15 @@ def test_constant_score(self):
         scored = qs.first()
         self.assertAlmostEqual(scored.score, 10.0, places=2)
 
+    def test_str_returns_expected_format(self):
+        score = SearchScoreOption({"constant": {"value": 10}})
+        se = SearchWildcard(path="headline", query="dark-*", score=score)
+        self.assertEqual(
+            str(se),
+            "<SearchWildcard(path='headline', query='dark-*', "
+            f"allow_analyzed_field=None, score={score})>",
+        )
+
 
 class SearchGeoShapeTests(SearchUtilsMixin):
     @classmethod
@@ -513,6 +597,20 @@ def test_constant_score(self):
         scored = qs.first()
         self.assertAlmostEqual(scored.score, 10.0, places=2)
 
+    def test_str_returns_expected_format(self):
+        score = SearchScoreOption({"constant": {"value": 10}})
+        polygon = {
+            "type": "Polygon",
+            "coordinates": [[[30, 0], [50, 0], [50, 10], [30, 10], [30, 0]]],
+        }
+        se = SearchGeoShape(path="location", relation="within", geometry=polygon, score=score)
+        self.assertEqual(
+            str(se),
+            "<SearchGeoShape(path='location', relation='within', geometry=(('type', 'Polygon'), "
+            "('coordinates', (((30, 0), (50, 0), (50, 10), (30, 10), (30, 0)),))), "
+            f"score={score})>",
+        )
+
 
 class SearchGeoWithinTests(SearchUtilsMixin):
     @classmethod
@@ -567,8 +665,29 @@ def test_constant_score(self):
         scored = qs.first()
         self.assertAlmostEqual(scored.score, 10.0, places=2)
 
+    def test_str_returns_expected_format(self):
+        score = SearchScoreOption({"constant": {"value": 10}})
+        polygon = {
+            "type": "Polygon",
+            "coordinates": [[[30, 0], [50, 0], [50, 10], [30, 10], [30, 0]]],
+        }
+        se = SearchGeoWithin(
+            path="location",
+            kind="geometry",
+            geometry=polygon,
+            score=score,
+        )
+        self.assertEqual(
+            str(se),
+            "<SearchGeoWithin(path='location', kind='geometry', geometry=(('type', 'Polygon'), "
+            "('coordinates', (((30, 0), (50, 0), (50, 10), (30, 10), (30, 0)),))), "
+            f"score={score})>",
+        )
+
 
-@unittest.expectedFailure
+@unittest.expectedFailure(
+    "Cannot find a match for the provided reference documents in Atlas Search"
+)
 class SearchMoreLikeThisTests(SearchUtilsMixin):
     @classmethod
     def setUpClass(cls):
@@ -770,6 +889,26 @@ def test_search_and_filter(self):
         qs = Article.objects.filter(headline__search="space exploration", number__gt=2)
         self.assertCountEqual(qs.all, [self.icy_moons])
 
+    def test_str_returns_expected_format(self):
+        must_expr = SearchEquals(path="headline", value="space exploration")
+        must_not_expr = SearchPhrase(path="body", query="icy moons")
+        should_expr = SearchPhrase(path="body", query="exoplanets")
+
+        se = CompoundExpression(
+            must=[must_expr or should_expr],
+            must_not=[must_not_expr],
+            should=[should_expr],
+            minimum_should_match=1,
+        )
+        self.assertEqual(
+            str(se),
+            "<CompoundExpression(must=(<SearchEquals(path='headline', value='space exploration', "
+            "score=None)>,), must_not=(<SearchPhrase(path='body', query='icy moons', slop=None, "
+            "synonyms=None, score=None)>,), should=(<SearchPhrase(path='body', "
+            "query='exoplanets', slop=None, synonyms=None, score=None)>,), "
+            "filter=None, score=None, minimum_should_match=1)>",
+        )
+
 
 class SearchVectorTests(SearchUtilsMixin):
     @classmethod
@@ -816,3 +955,17 @@ def test_vector_search(self):
         )
         qs = Article.objects.annotate(score=expr).order_by("-score")
         self.assertCountEqual(qs.all, [self.mars, self.cooking])
+
+    def test_str_returns_expected_format(self):
+        vector_query = [0.1, 0.2, 0.3]
+        se = SearchVector(
+            path="plot_embedding",
+            query_vector=vector_query,
+            num_candidates=5,
+            limit=2,
+        )
+        self.assertEqual(
+            str(se),
+            "<SearchVector(path='plot_embedding', query_vector=(0.1, 0.2, 0.3), limit=2, "
+            "num_candidates=5, exact=None, filter=None)>",
+        )