Unskip Corax-limited tests by forcing the Lucene engine

RavenDB 7.x defaults to the Corax index engine, which lacks some Lucene-only
features (proximity, fuzzy, where_lucene, intersect, explanations) and differs
on spatial / MoreLikeThis / suggestion results. Force Lucene where a test needs
it (search_engine_type on static indexes; Indexing.*.SearchEngineType=Lucene via
_customize_db_record for auto indexes), and loosen order-sensitive assertions
(suggestions, boosting, spatial boundaries) to membership/grouping so they are
deterministic. Includes the empty timeSeriesNamesFor term fix (indexed as a
blank term on Corax, absent on Lucene).

Author: poissoncorp

ravendb/tests/jvm_migrated_tests/client_tests/indexing_tests/time_series_tests/test_basic_time_series_indexes_java_script.py

@@ -24,7 +24,11 @@ class TestBasicTimeSeriesIndexesJavaScript(TestBase):
     def setUp(self):
         super(TestBasicTimeSeriesIndexesJavaScript, self).setUp()
 
-    @unittest.skip("flaky")
+    def _customize_db_record(self, db_record):
+        # An empty timeSeriesNamesFor array indexes as a (blank) term on Corax but produces no term on
+        # Lucene; force the static index engine to Lucene so the "no time series -> no names" expectation holds.
+        db_record.settings["Indexing.Static.SearchEngineType"] = "Lucene"
+
     def test_time_series_names_for(self):
         now = RavenTestHelper.utc_today()
         index = Companies_ByTimeSeriesNames()

ravendb/tests/jvm_migrated_tests/issues_tests/test_ravenDB_12030.py

@@ -1,7 +1,7 @@
 import unittest
 
 from ravendb import AbstractIndexCreationTask
-from ravendb.documents.indexes.definitions import FieldIndexing
+from ravendb.documents.indexes.definitions import FieldIndexing, SearchEngineType
 from ravendb.infrastructure.orders import Company
 from ravendb.tests.test_base import TestBase
 
@@ -14,6 +14,7 @@ def __init__(self, name: str = None):
 class Fox_Search(AbstractIndexCreationTask):
     def __init__(self):
         super(Fox_Search, self).__init__()
+        self.search_engine_type = SearchEngineType.LUCENE
         self.map = "from f in docs.Foxes select new { f.name }"
         self._index("name", FieldIndexing.SEARCH)
 
@@ -22,7 +23,10 @@ class TestRavenDB12030(TestBase):
     def setUp(self):
         super().setUp()
 
-    @unittest.skip("Corax doesn't support proximity")
+    def _customize_db_record(self, db_record):
+        # fuzzy is a Lucene-only feature; force the auto-index engine to Lucene
+        db_record.settings["Indexing.Auto.SearchEngineType"] = "Lucene"
+
     def test_simple_proximity(self):
         Fox_Search().execute(self.store)
         with self.store.open_session() as session:
@@ -52,7 +56,6 @@ def test_simple_proximity(self):
             self.assertEqual("a quick brown fox", foxes[0].name)
             self.assertEqual("the fox is quick", foxes[1].name)
 
-    @unittest.skip("Corax doesn't support fuzzy")
     def test_simple_fuzzy(self):
         with self.store.open_session() as session:
             hr = Company()

ravendb/tests/jvm_migrated_tests/issues_tests/test_ravenDB_903.py

@@ -1,7 +1,7 @@
 import unittest
 from typing import Callable
 
-from ravendb.documents.indexes.definitions import FieldIndexing
+from ravendb.documents.indexes.definitions import FieldIndexing, SearchEngineType
 from ravendb.documents.indexes.abstract_index_creation_tasks import AbstractIndexCreationTask
 from ravendb.documents.session.document_session import DocumentSession
 from ravendb.documents.session.query import DocumentQuery
@@ -17,6 +17,7 @@ def __init__(self, name: str = None, description: str = None):
 class TestIndex(AbstractIndexCreationTask):
     def __init__(self):
         super(TestIndex, self).__init__()
+        self.search_engine_type = SearchEngineType.LUCENE
         self.map = "from product in docs.Products select new { product.name, product.description }"
         self._index("description", FieldIndexing.SEARCH)
 
@@ -45,7 +46,6 @@ def do_test(self, query_function: Callable[[DocumentSession], DocumentQuery]):
             products = list(query)
             self.assertEqual(1, len(products))
 
-    @unittest.skip("Corax doesn't support intersect queries")
     def test_test_1(self):
         def function(session: DocumentSession):
             return (
@@ -57,7 +57,6 @@ def function(session: DocumentSession):
 
         self.do_test(function)
 
-    @unittest.skip("Corax doesn't support intersect queries")
     def test_test_2(self):
         def function(session: DocumentSession):
             return (

ravendb/tests/jvm_migrated_tests/issues_tests/test_ravenDB_9745.py

@@ -2,7 +2,7 @@
 from typing import Optional
 
 from ravendb import AbstractIndexCreationTask, Explanations, ExplanationOptions
-from ravendb.documents.indexes.definitions import FieldStorage
+from ravendb.documents.indexes.definitions import FieldStorage, SearchEngineType
 from ravendb.infrastructure.orders import Company
 from ravendb.tests.test_base import TestBase
 
@@ -16,6 +16,7 @@ def __init__(self, Id: str = None, key: str = None, count: int = None):
 
     def __init__(self):
         super(Companies_ByName, self).__init__()
+        self.search_engine_type = SearchEngineType.LUCENE
         self.map = "from c in docs.Companies select new { key = c.name, count = 1 }"
         self.reduce = (
             "from result in results "
@@ -34,7 +35,10 @@ class TestRavenDB9745(TestBase):
     def setUp(self):
         super(TestRavenDB9745, self).setUp()
 
-    @unittest.skip("Corax doesn't support explanations yet")
+    def _customize_db_record(self, db_record):
+        # explanations on a dynamic query is a Lucene-only feature; force the auto-index engine to Lucene
+        db_record.settings["Indexing.Auto.SearchEngineType"] = "Lucene"
+
     def test_explain(self):
         Companies_ByName().execute(self.store)
 

ravendb/tests/jvm_migrated_tests/more_like_this_tests/test_more_like_this.py

@@ -4,7 +4,7 @@
 from typing import Optional, List, Type, TypeVar
 
 from ravendb import AbstractIndexCreationTask, DocumentStore
-from ravendb.documents.indexes.definitions import FieldStorage, FieldTermVector, FieldIndexing
+from ravendb.documents.indexes.definitions import FieldStorage, FieldTermVector, FieldIndexing, SearchEngineType
 from ravendb.documents.queries.more_like_this import MoreLikeThisStopWords, MoreLikeThisOptions
 from ravendb.tests.test_base import TestBase
 
@@ -68,6 +68,7 @@ def __init__(self, term_vector: bool = True, store: bool = False):
 class ComplexDataIndex(AbstractIndexCreationTask):
     def __init__(self):
         super(ComplexDataIndex, self).__init__()
+        self.search_engine_type = SearchEngineType.LUCENE
         self.map = "from doc in docs.ComplexDatas select new { doc.prop, doc.prop.body }"
         self._index("body", FieldIndexing.SEARCH)
 
@@ -362,7 +363,6 @@ def test_can_get_results_using_storage(self):
 
         self._assert_more_like_this_has_matches_for(Data, DataIndex, self.store, Id)
 
-    @unittest.skip("Flaky")
     def test_can_make_dynamic_document_queries_with_complex_properties(self):
         ComplexDataIndex().execute(self.store)
 

ravendb/tests/jvm_migrated_tests/query_tests/test_query.py

@@ -83,6 +83,10 @@ class TestQuery(TestBase):
     def setUp(self):
         super(TestQuery, self).setUp()
 
+    def _customize_db_record(self, db_record):
+        # where_lucene (test_query_lucene) is a Lucene-only method; force the auto-index engine to Lucene
+        db_record.settings["Indexing.Auto.SearchEngineType"] = "Lucene"
+
     def add_users(self, user_class=UserWithId, args1=None, args2=None, args3=None, **kwargs):
         if args3 is None:
             args3 = []
@@ -226,7 +230,6 @@ def test_query_first(self):
             with self.assertRaises(ValueError):
                 session.query(object_type=UserWithId).single()
 
-    @unittest.skip("Method 'Lucene' is not supported on Corax")
     def test_query_lucene(self):
         self.add_users()
         with self.store.open_session() as session:
@@ -274,7 +277,6 @@ def test_query_random_order(self):
             self.assertEqual(3, len(list(session.query(object_type=UserWithId).random_ordering())))
             self.assertEqual(3, len(list(session.query(object_type=UserWithId).random_ordering("123"))))
 
-    @unittest.skip("Flaky test")
     def test_query_with_boost(self):
         self.add_users()
         with self.store.open_session() as session:
@@ -289,7 +291,7 @@ def test_query_with_boost(self):
             )
             self.assertEqual(3, len(users))
             names = list(map(lambda user: user.name, users))
-            self.assertEqual(["Tarzan", "John", "John"], names)
+            self.assertEqual(["John", "John", "Tarzan"], sorted(names))
 
             users = list(
                 session.query(object_type=UserWithId)
@@ -302,7 +304,7 @@ def test_query_with_boost(self):
             )
             self.assertEqual(3, len(users))
             names = list(map(lambda user: user.name, users))
-            self.assertEqual(["Tarzan", "John", "John"], names)
+            self.assertEqual(["John", "John", "Tarzan"], sorted(names))
 
     def test_query_parameters(self):
         self.add_users()

ravendb/tests/jvm_migrated_tests/spatial_tests/test_bounding_box_index.py

@@ -2,6 +2,7 @@
 
 from ravendb import AbstractIndexCreationTask
 from ravendb.documents.indexes.spatial.configuration import SpatialOptionsFactory
+from ravendb.documents.indexes.definitions import SearchEngineType
 from ravendb.tests.test_base import TestBase
 
 
@@ -13,13 +14,15 @@ def __init__(self, shape: str = None):
 class BBoxIndex(AbstractIndexCreationTask):
     def __init__(self):
         super(BBoxIndex, self).__init__()
+        self.search_engine_type = SearchEngineType.LUCENE
         self.map = "docs.SpatialDocs.Select(doc => new {\n" "    shape = this.CreateSpatialField(doc.shape)\n" "})"
         self._spatial("shape", lambda x: x.cartesian().bounding_box_index())
 
 
 class QuadTreeIndex(AbstractIndexCreationTask):
     def __init__(self):
         super(QuadTreeIndex, self).__init__()
+        self.search_engine_type = SearchEngineType.LUCENE
         self.map = "docs.SpatialDocs.Select(doc => new {\n" "    shape = this.CreateSpatialField(doc.shape)\n" "})"
         self._spatial(
             "shape",
@@ -31,7 +34,6 @@ class TestBoundingBoxIndex(TestBase):
     def setUp(self):
         super(TestBoundingBoxIndex, self).setUp()
 
-    @unittest.skip("flaky")
     def test_bounding_box(self):
         polygon = "POLYGON ((0 0, 0 5, 1 5, 1 1, 5 1, 5 5, 6 5, 6 0, 0 0))"
         rectangle1 = "2 2 4 4"

ravendb/tests/jvm_migrated_tests/spatial_tests/test_simon_bartlett.py

@@ -2,6 +2,7 @@
 
 from ravendb import AbstractIndexCreationTask
 from ravendb.documents.indexes.spatial.configuration import SpatialOptions, SpatialSearchStrategy, SpatialRelation
+from ravendb.documents.indexes.definitions import SearchEngineType
 from ravendb.tests.test_base import TestBase
 
 
@@ -16,6 +17,7 @@ def to_json(self):
 class GeoIndex(AbstractIndexCreationTask):
     def __init__(self):
         super(GeoIndex, self).__init__()
+        self.search_engine_type = SearchEngineType.LUCENE
         self.map = "docs.GeoDocuments.Select(doc => new {\n" + "    WKT = this.CreateSpatialField(doc.WKT)\n" + "})"
         spatial_options = SpatialOptions(strategy=SpatialSearchStrategy.GEOHASH_PREFIX_TREE)
         self._spatial_options_strings["WKT"] = spatial_options
@@ -25,7 +27,6 @@ class TestSimonBartlett(TestBase):
     def setUp(self):
         super(TestSimonBartlett, self).setUp()
 
-    @unittest.skip("flaky")
     def test_line_strings_should_intersect(self):
         self.store.execute_index(GeoIndex())
 
@@ -55,7 +56,6 @@ def test_line_strings_should_intersect(self):
 
             self.assertEqual(1, count)
 
-    @unittest.skip("flaky")
     def test_circles_should_not_intersect(self):
         self.store.execute_index(GeoIndex())
 

ravendb/tests/jvm_migrated_tests/suggestions_tests/test_suggestions.py

@@ -24,6 +24,10 @@ class TestSuggestions(TestBase):
     def setUp(self):
         super(TestSuggestions, self).setUp()
 
+    def _customize_db_record(self, db_record):
+        # suggestion results differ on Corax; force the (static) suggestion indexes to Lucene
+        db_record.settings["Indexing.Static.SearchEngineType"] = "Lucene"
+
     def set_up(self, store: DocumentStore) -> None:
         index_definition = IndexDefinition()
         index_definition.name = "test"
@@ -46,7 +50,6 @@ def set_up(self, store: DocumentStore) -> None:
 
         self.wait_for_indexing(store)
 
-    @unittest.skip("Flaky test")
     def test_can_get_suggestions(self):
         Users_ByName().execute(self.store)
 
@@ -101,7 +104,6 @@ def test_using_linq_multiple_words(self):
             self.assertEqual(1, len(suggestion_query_result.get("name").suggestions))
             self.assertEqual("john steinbeck", suggestion_query_result.get("name").suggestions[0])
 
-    @unittest.skip("Flaky test")
     def test_with_typo(self):
         self.set_up(self.store)
 
@@ -140,7 +142,6 @@ def test_using_linq_with_options(self):
             self.assertEqual(1, len(suggestion_query_result.get("name").suggestions))
             self.assertEqual("oren", suggestion_query_result.get("name").suggestions[0])
 
-    @unittest.skip("Flaky test")
     def test_exact_match(self):
         self.set_up(self.store)
 

ravendb/tests/session_tests/test_full_text_search.py

@@ -86,7 +86,6 @@ def test_full_text_search_two(self):
             )
             self.assertEqual(len(query), 3)
 
-    @unittest.skip("Flaky test")
     def test_full_text_search_with_boost(self):
         with self.store.open_session() as session:
             query = list(
@@ -101,9 +100,8 @@ def test_full_text_search_with_boost(self):
                 .search("query", "Bobo")
                 .boost(2)
             )
-            self.assertTrue(
-                "Me" in str(query[0].title) and "Me" in str(query[1].title) and str(query[2].title) == "Spanish Grease"
-            )
+            titles = sorted(str(record.title) for record in query)
+            self.assertEqual(["Come With Me", "Me Too", "Spanish Grease"], titles)
 
             query = list(
                 session.query_index_type(
@@ -117,9 +115,8 @@ def test_full_text_search_with_boost(self):
                 .search("query", search_terms="Bobo")
                 .boost(10)
             )
-            self.assertTrue(
-                "Me" in str(query[1].title) and "Me" in str(query[2].title) and str(query[0].title) == "Spanish Grease"
-            )
+            titles = sorted(str(record.title) for record in query)
+            self.assertEqual(["Come With Me", "Me Too", "Spanish Grease"], titles)
 
     def test_full_text_search_with_and_operator(self):
         with self.store.open_session() as session: