RDBC-692 RavenDB_11217Test::sessionWideNoTrackingShouldWork

Author: poissoncorp

ravendb/documents/session/document_session.py

@@ -346,8 +346,8 @@ def __load_internal_stream(self, keys: List[str], operation: LoadOperation, stre
 
     def load_starting_with(
         self,
-        object_type: Type[_T],
         id_prefix: str,
+        object_type: Optional[Type[_T]] = None,
         matches: Optional[str] = None,
         start: Optional[int] = None,
         page_size: Optional[int] = None,
@@ -727,17 +727,16 @@ def __load_starting_with_internal(
 
         def load_starting_with(
             self,
-            object_type: type,
             id_prefix: str,
-            matches: str,
-            start: int,
-            page_size: int,
-            exclude: str,
-            start_after: str,
-        ) -> object:
-            load_starting_with_operation = LoadStartingWithOperation(self._session)
-            self.__load_starting_with_internal(
-                id_prefix, load_starting_with_operation, None, matches, start, page_size, exclude, start_after
+            object_type: Optional[Type[_T]] = None,
+            matches: Optional[str] = None,
+            start: Optional[int] = None,
+            page_size: Optional[int] = None,
+            exclude: Optional[str] = None,
+            start_after: Optional[str] = None,
+        ) -> List[_T]:
+            return self._session.load_starting_with(
+                id_prefix, object_type, matches, start, page_size, exclude, start_after
             )
 
         def load_starting_with_into_stream(

ravendb/documents/session/operations/lazy.py

@@ -210,8 +210,8 @@ def load(
 
     def load_starting_with(
         self,
-        object_type: Type[_T],
         id_prefix: str,
+        object_type: Optional[Type[_T]],
         matches: str = None,
         start: int = 0,
         page_size: int = 25,

ravendb/tests/counters_tests/test_query_on_counters.py

@@ -692,12 +692,12 @@ def test_counters_should_be_cached_on_collection(self):
             session.counters_for("orders/1-A").increment("downloads", 200)
             session.save_changes()
 
-            list(session.query(object_type=Order).include(lambda i: i.include_counters(["downloads"])))
+            list(session.query(object_type=Order).include(lambda i: i.include_counters("downloads")))
             self.assertEqual(300, session.counters_for("orders/1-A").get("downloads"))
             session.counters_for("orders/1-A").increment("downloads", 200)
             session.save_changes()
 
-            list(session.query(object_type=Order).include(lambda i: i.include_counters(["downloads"])))
+            list(session.query(object_type=Order).include(lambda i: i.include_counters("downloads")))
             self.assertEqual(500, session.counters_for("orders/1-A").get("downloads"))
 
         with self.store.open_session() as session:

ravendb/tests/jvm_migrated_tests/issues_tests/test_ravenDB_11217.py

@@ -2,32 +2,150 @@
 
 from ravendb.documents.session.misc import SessionOptions
 from ravendb.documents.session.query import QueryStatistics
-from ravendb.infrastructure.orders import Product
+from ravendb.infrastructure.orders import Product, Supplier
 from ravendb.tests.test_base import TestBase
 
 
 class TestRavenDB11217(TestBase):
     def setUp(self):
         super(TestRavenDB11217, self).setUp()
 
-    def test_session_wide_no_caching_should_work(self):
+    def test_session_wide_no_tracking_should_work(self):
         with self.store.open_session() as session:
-            stats: Optional[QueryStatistics] = None
+            supplier = Supplier()
+            supplier.name = "Supplier1"
 
-            def __stats_callback(statistics: QueryStatistics):
-                nonlocal stats
-                stats = statistics
+            session.store(supplier)
 
-            list(session.query(object_type=Product).statistics(__stats_callback).where_equals("name", "HR"))
-            self.assertGreaterEqual(stats.duration_in_ms, 0)
-            list(session.query(object_type=Product).statistics(__stats_callback).where_equals("name", "HR"))
-            self.assertEqual(-1, stats.duration_in_ms)
+            product = Product()
+            product.name = "Product1"
+            product.supplier = supplier.Id
 
-        no_cache_options = SessionOptions()
-        no_cache_options.no_caching = True
+            session.store(product)
+            session.save_changes()
 
-        with self.store.open_session(session_options=no_cache_options) as session:
-            list(session.query(object_type=Product).statistics(__stats_callback).where_equals("name", "HR"))
-            self.assertGreaterEqual(stats.duration_in_ms, 0)
-            list(session.query(object_type=Product).statistics(__stats_callback).where_equals("name", "HR"))
-            self.assertGreaterEqual(stats.duration_in_ms, 0)
+        no_tracking_options = SessionOptions()
+        no_tracking_options.no_tracking = True
+
+        with self.store.open_session(session_options=no_tracking_options) as session:
+            supplier = Supplier()
+            supplier.name = "Supplier2"
+
+            with self.assertRaises(RuntimeError):
+                session.store(supplier)
+
+        with self.store.open_session(session_options=no_tracking_options) as session:
+            self.assertEqual(0, session.advanced.number_of_requests)
+
+            product1 = session.load("products/1-A", Product, lambda b: b.include_documents("supplier"))
+
+            self.assertEqual(1, session.advanced.number_of_requests)
+
+            self.assertIsNotNone(product1)
+            self.assertEqual("Product1", product1.name)
+            self.assertFalse(session.advanced.is_loaded(product1.Id))
+            self.assertFalse(session.advanced.is_loaded(product1.supplier))
+
+            supplier = session.load(product1.supplier, Supplier)
+            self.assertIsNotNone(supplier)
+            self.assertEqual("Supplier1", supplier.name)
+            self.assertEqual(2, session.advanced.number_of_requests)
+            self.assertFalse(session.advanced.is_loaded(supplier.Id))
+
+            product2 = session.load("products/1-A", Product, lambda b: b.include_documents(("supplier")))
+            self.assertNotEqual(product2, product1)
+
+        with self.store.open_session(session_options=no_tracking_options) as session:
+            self.assertEqual(0, session.advanced.number_of_requests)
+
+            product1 = session.advanced.load_starting_with("products/", Product)[0]
+
+            self.assertEqual(1, session.advanced.number_of_requests)
+
+            self.assertIsNotNone(product1)
+            self.assertEqual("Product1", product1.name)
+            self.assertFalse(session.advanced.is_loaded(product1.Id))
+            self.assertFalse(session.advanced.is_loaded(product1.supplier))
+
+            supplier = session.advanced.load_starting_with(product1.supplier, Supplier)[0]
+
+            self.assertIsNotNone(supplier)
+            self.assertEqual("Supplier1", supplier.name)
+            self.assertEqual(2, session.advanced.number_of_requests)
+            self.assertFalse(session.advanced.is_loaded(supplier.Id))
+
+            product2 = session.advanced.load_starting_with("products/", Product)[0]
+            self.assertNotEqual(product2, product1)
+
+        with self.store.open_session(session_options=no_tracking_options) as session:
+            self.assertEqual(0, session.advanced.number_of_requests)
+            products = list(session.query(object_type=Product).include("supplier"))
+
+            self.assertEqual(1, session.advanced.number_of_requests)
+            self.assertEqual(1, len(products))
+
+            product1 = products[0]
+            self.assertIsNotNone(product1)
+            self.assertFalse(session.advanced.is_loaded(product1.Id))
+            self.assertFalse(session.advanced.is_loaded(product1.supplier))
+
+            supplier = session.load(product1.supplier, Supplier)
+            self.assertIsNotNone(supplier)
+            self.assertEqual("Supplier1", supplier.name)
+            self.assertEqual(2, session.advanced.number_of_requests)
+            self.assertFalse(session.advanced.is_loaded(supplier.Id))
+
+            products = list(session.query(object_type=Product).include("supplier"))
+            self.assertEqual(1, len(products))
+
+            product2 = products[0]
+            self.assertNotEqual(product2, product1)
+
+        with self.store.open_session() as session:
+            session.counters_for("products/1-A").increment("c1")
+            session.save_changes()
+
+        with self.store.open_session(session_options=no_tracking_options) as session:
+            product1 = session.load("products/1-A", Product)
+            counters = session.counters_for(product1.Id)
+
+            counters.get("c1")
+
+            self.assertEqual(2, session.advanced.number_of_requests)
+
+            counters.get("c1")
+
+            self.assertEqual(3, session.advanced.number_of_requests)
+
+            val1 = counters.get_all()
+
+            self.assertEqual(4, session.advanced.number_of_requests)
+
+            val2 = counters.get_all()
+
+            self.assertEqual(5, session.advanced.number_of_requests)
+
+            self.assertNotEqual(id(val2), id(val1))
+
+
+def test_session_wide_no_caching_should_work(self):
+    with self.store.open_session() as session:
+        stats: Optional[QueryStatistics] = None
+
+        def __stats_callback(statistics: QueryStatistics):
+            nonlocal stats
+            stats = statistics
+
+        list(session.query(object_type=Product).statistics(__stats_callback).where_equals("name", "HR"))
+        self.assertGreaterEqual(stats.duration_in_ms, 0)
+        list(session.query(object_type=Product).statistics(__stats_callback).where_equals("name", "HR"))
+        self.assertEqual(-1, stats.duration_in_ms)
+
+    no_cache_options = SessionOptions()
+    no_cache_options.no_caching = True
+
+    with self.store.open_session(session_options=no_cache_options) as session:
+        list(session.query(object_type=Product).statistics(__stats_callback).where_equals("name", "HR"))
+        self.assertGreaterEqual(stats.duration_in_ms, 0)
+        list(session.query(object_type=Product).statistics(__stats_callback).where_equals("name", "HR"))
+        self.assertGreaterEqual(stats.duration_in_ms, 0)

ravendb/tests/jvm_migrated_tests/mailing_list_tests/test_load_all_starting_with.py

@@ -25,7 +25,7 @@ def test_load_all_starting_with(self):
             session.save_changes()
 
         with self.store.open_session() as session:
-            test_classes = session.advanced.lazily.load_starting_with(Abc, "abc/")
+            test_classes = session.advanced.lazily.load_starting_with("abc/", Abc)
 
             test2_classes = session.query(object_type=Xyz).wait_for_non_stale_results().lazily().value
             self.assertEqual(1, len(test_classes.value))

ravendb/tests/operations_tests/test_operations.py

@@ -82,7 +82,7 @@ def test_patch_by_index(self):
         )
         operation.wait_for_completion()
         with self.store.open_session() as session:
-            result = session.load_starting_with(Patch, "patches")
+            result = session.load_starting_with("patches", Patch)
             values = list(map(lambda patch: patch.patched, result))
             self.assertEqual(3, len(result))
             self.assertEqual(3, len(values))
@@ -135,7 +135,7 @@ def test_delete_by_index(self):
         )
         operation.wait_for_completion()
         with self.store.open_session() as session:
-            result = session.load_starting_with(User, "users")
+            result = session.load_starting_with("users", User)
             self.assertEqual(1, len(result))
             self.assertNotEqual("delete", result[0].name)
 
@@ -159,15 +159,15 @@ def test_patch_by_collection(self):
         )
         operation.wait_for_completion()
         with self.store.open_session() as session:
-            result = session.load_starting_with(Patch, "patches")
+            result = session.load_starting_with("patches", Patch)
             values = map(lambda patch: patch.patched, result)
 
             for v in values:
                 self.assertTrue(v)
 
     def test_delete_by_collection_(self):
         with self.store.open_session() as session:
-            self.assertEqual(1, len(session.load_starting_with(User, "users")))
+            self.assertEqual(1, len(session.load_starting_with("users", User)))
         index_query = IndexQuery("From Users")
         operation = DeleteByQueryOperation(query_to_delete=index_query)
         result = self.store.operations.send(operation)
@@ -180,7 +180,7 @@ def test_delete_by_collection_(self):
         )
         op.wait_for_completion()
         with self.store.open_session() as session:
-            self.assertEqual(0, len(session.load_starting_with(User, "users")))
+            self.assertEqual(0, len(session.load_starting_with("users", User)))
 
 
 if __name__ == "__main__":

ravendb/tests/raven_commands_tests/test_get_by_prefix.py

@@ -36,27 +36,27 @@ def tearDown(self):
 
     def test_start_with(self):
         with self.store.open_session() as session:
-            response = session.load_starting_with(dict, "products/MB-")
+            response = session.load_starting_with("products/MB-", dict)
         self.assertEqual(4, len(response))
 
     def test_matches(self):
         with self.store.open_session() as session:
-            response = session.load_starting_with(dict, "products/MB-", matches="2*")
+            response = session.load_starting_with("products/MB-", dict, matches="2*")
         self.assertEqual(2, len(response))
 
     def test_excludes(self):
         with self.store.open_session() as session:
-            response = session.load_starting_with(dict, "products/BM-", exclude="2*")
+            response = session.load_starting_with("products/BM-", dict, exclude="2*")
         self.assertEqual(1, len(response))
 
     def test_start_after(self):
         with self.store.open_session() as session:
-            response = session.load_starting_with(dict, "products/MB-", matches="2*", start_after="products/MB-200")
+            response = session.load_starting_with("products/MB-", dict, matches="2*", start_after="products/MB-200")
         self.assertEqual(1, len(response))
 
     def test_page(self):
         with self.store.open_session() as session:
-            response = session.load_starting_with(dict, "products/MB", start=1, page_size=2)
+            response = session.load_starting_with("products/MB", dict, start=1, page_size=2)
         self.assertEqual(2, len(response))