RDBC-644 RavenDB_16301Test::canUseConditionalLoadLazily

Author: poissoncorp

ravendb/documents/queries/query.py

@@ -80,6 +80,10 @@ def __init__(
         self.project_into: Union[None, bool] = None
         self.projection_behavior: Union[None, ProjectionBehavior] = None
 
+    @classmethod
+    def custom_function(cls, alias: str, func: str) -> QueryData:
+        return cls([func], [], alias, None, None, True)
+
 
 class QueryResultBase(Generic[_TResult, _TIncludes]):
     @abstractmethod

ravendb/documents/session/operations/lazy.py

@@ -20,7 +20,7 @@
 from ravendb.tools.utils import Utils, CaseInsensitiveDict
 from ravendb.documents.queries.query import QueryResult
 from ravendb.extensions.json_extensions import JsonExtensions
-from ravendb.documents.commands.crud import GetDocumentsResult, ConditionalGetDocumentsCommand
+from ravendb.documents.commands.crud import GetDocumentsResult, ConditionalGetDocumentsCommand, ConditionalGetResult
 from ravendb.documents.session.operations.load_operation import LoadOperation
 from ravendb.documents.conventions import DocumentConventions
 from ravendb.documents.operations.lazy.lazy_operation import LazyOperation
@@ -166,7 +166,7 @@ def handle_response(self, response: "GetResponse") -> None:
             if response.result is not None:
                 etag = response.headers.get(constants.Headers.ETAG)
 
-                res = ConditionalGetDocumentsCommand.ConditionalGetResult.from_json(json.loads(response.result))
+                res = ConditionalGetResult.from_json(json.loads(response.result))
                 document_info = DocumentInfo.get_new_document_info(res.results[0])
                 r = self.__session.track_entity_document_info(self.__object_type, document_info)
 
@@ -227,7 +227,7 @@ def load_starting_with(
     def conditional_load(
         self, key: str, change_vector: str, object_type: Type[_T] = None
     ) -> Lazy[ConditionalLoadResult[_T]]:
-        if not key.isspace():
+        if not key or key.isspace():
             raise ValueError("key cannot be None or whitespace")
 
         if self._delegate.is_loaded(key):
@@ -236,7 +236,7 @@ def __lazy_factory():
                 entity = self._delegate.load(key, object_type)
                 if entity is None:
                     return ConditionalLoadResult.create(None, None)
-                cv = self._delegate.get_change_vector_for(entity)
+                cv = self._delegate.advanced.get_change_vector_for(entity)
                 return ConditionalLoadResult.create(entity, cv)
 
             return Lazy(__lazy_factory)

ravendb/documents/session/operations/load_operation.py

@@ -99,8 +99,8 @@ def with_time_series(self, time_series: List[TimeSeriesRange]):
             self._time_series_to_include = time_series
         return self
 
-    def by_keys(self, keys: List[str]):
-        distinct = CaseInsensitiveSet(filter(lambda key: key and key.strip(), keys))
+    def by_keys(self, keys: List[Optional[str]]):
+        distinct = CaseInsensitiveSet(filter(lambda x: x and not x.isspace(), keys))
         self._keys = list(distinct)
         return self
 

ravendb/tests/jvm_migrated_tests/client_tests/test_bulk_inserts.py

@@ -74,4 +74,3 @@ def test_killed_to_early(self):
                 time.sleep(0.1)  # todo: wait for operation to be created first, then try to kill it
                 bulk_insert.abort()
                 bulk_insert.store_by_entity(FooBar())
-

ravendb/tests/jvm_migrated_tests/issues_tests/test_ravenDB_16301.py

@@ -0,0 +1,86 @@
+from typing import List
+
+from ravendb import Lazy, ConditionalLoadResult, QueryData
+from ravendb.infrastructure.orders import Company
+from ravendb.tests.test_base import TestBase
+
+
+class Result:
+    def __init__(self, Id: str = None, change_vector: str = None):
+        self.Id = Id
+        self.change_vector = change_vector
+
+
+class TestRavenDB16301(TestBase):
+    def setUp(self):
+        super(TestRavenDB16301, self).setUp()
+
+    def test_can_use_conditional_load_lazily(self):
+        with self.store.bulk_insert() as bulk_insert:
+            for i in range(100):
+                bulk_insert.store_by_entity(Company())
+
+        ids: List[Result] = []
+        loads: List[Lazy[ConditionalLoadResult[Company]]] = []
+
+        with self.store.open_session() as session1:
+            ids = list(
+                session1.advanced.document_query(object_type=Company)
+                .wait_for_non_stale_results()
+                .select_fields_query_data(
+                    Result,
+                    QueryData.custom_function("o", "{ Id : id(o), change_vector : getMetadata(o)['@change-vector'] }"),
+                )
+            )
+
+            all_ids = [single_id.Id for single_id in ids]
+            session1.load(all_ids, Company)
+
+            res_ids = all_ids[0:50]
+
+            res = session1.load(res_ids, Company)
+
+            c = 0
+            for key in res:
+                c += 1
+                res[key].phone = c
+
+            session1.save_changes()
+
+        with self.store.open_session() as session:
+            # load last 10
+            session.load(all_ids[-10:])
+            number_of_requests_per_session = session.advanced.number_of_requests
+
+            for res in ids:
+                loads.append(session.advanced.lazily.conditional_load(res.Id, res.change_vector, Company))
+
+            session.advanced.eagerly.execute_all_pending_lazy_operations()
+
+            self.assertEqual(number_of_requests_per_session + 1, session.advanced.number_of_requests)
+
+            for i in range(100):
+                l = loads[i]
+
+                self.assertFalse(l.is_value_created)
+                conditional_load_resuilt = l.value
+
+                if i < 50:
+                    # load from server
+                    self.assertEqual(ids[i].Id, conditional_load_resuilt.entity.Id)
+                elif i < 90:
+                    # not modified
+                    self.assertIsNone(conditional_load_resuilt.entity)
+                    self.assertEqual(ids[i].change_vector, conditional_load_resuilt.change_vector)
+
+                else:
+                    # tracked in session
+                    self.assertEqual(ids[i].Id, conditional_load_resuilt.entity.Id)
+                    self.assertIsNotNone(conditional_load_resuilt.entity)
+                    self.assertEqual(ids[i].change_vector, conditional_load_resuilt.change_vector)
+
+                # not exist on server
+                lazy = session.advanced.lazily.conditional_load("Companies/322-A", ids[0].change_vector, Company)
+                load = lazy.value
+                self.assertIsNone(load.entity)
+                self.assertIsNone(load.change_vector)