RDBC-1048 Fix WaitFor replication/index settings silently ignored after SaveChanges

Author: redknightlois

ravendb/documents/session/document_session.py

@@ -828,7 +828,8 @@ def wait_for_replication_after_save_changes(
             builder_options = builder.get_options()
             replication_options = builder_options.replication_options
             if replication_options is None:
-                builder_options.replication_options = ReplicationBatchOptions()
+                replication_options = ReplicationBatchOptions()
+                builder_options.replication_options = replication_options
 
             if replication_options.wait_for_replicas_timeout is None:
                 replication_options.wait_for_replicas_timeout = (
@@ -847,7 +848,8 @@ def wait_for_indexes_after_save_changes(
             index_options = builder_options.index_options
 
             if index_options is None:
-                builder_options.index_options = IndexBatchOptions()
+                index_options = IndexBatchOptions()
+                builder_options.index_options = index_options
 
             if index_options.wait_for_indexes_timeout is None:
                 index_options.wait_for_indexes_timeout = (

ravendb/documents/session/document_session_operations/in_memory_document_session_operations.py

@@ -1857,7 +1857,7 @@ def get_options(self) -> BatchOptions:
         def with_timeout(
             self, timeout: datetime.timedelta
         ) -> InMemoryDocumentSessionOperations.ReplicationWaitOptsBuilder:
-            self.get_options().replication_options.wait_for_indexes_timeout = timeout
+            self.get_options().replication_options.wait_for_replicas_timeout = timeout
             return self
 
         def throw_on_timeout(self, should_throw: bool) -> InMemoryDocumentSessionOperations.ReplicationWaitOptsBuilder:
@@ -1890,11 +1890,13 @@ def with_timeout(self, timeout: datetime.timedelta) -> InMemoryDocumentSessionOp
             return self
 
         def throw_on_timeout(self, should_throw: bool) -> InMemoryDocumentSessionOperations.IndexesWaitOptsBuilder:
-            self.get_options().index_options.throw_on_timeout_in_wait_for_replicas = should_throw
+            self.get_options().index_options.throw_on_timeout_in_wait_for_indexes = should_throw
             return self
 
-        def wait_for_indexes(self, *indexes: str) -> InMemoryDocumentSessionOperations.IndexesWaitOptsBuilder:
-            self.get_options().index_options.wait_for_indexes = indexes
+        def wait_for_indexes(
+            self, indexes: Optional[List[str]] = None
+        ) -> InMemoryDocumentSessionOperations.IndexesWaitOptsBuilder:
+            self.get_options().index_options.wait_for_specific_indexes = indexes
             return self
 
     class SaveChangesData:

ravendb/tests/session_tests/test_advanced.py

@@ -3,6 +3,7 @@
 from ravendb.documents.operations.indexes import PutIndexesOperation
 from ravendb.tests.test_base import TestBase
 from ravendb.exceptions.exceptions import InvalidOperationException
+import datetime
 import unittest
 import pathlib
 import os
@@ -126,6 +127,74 @@ def test_try_delete_attachment_putted_in_the_same_session(self):
                 with self.assertRaises(InvalidOperationException):
                     session.advanced.attachments.delete("users/1-A", "my_text_file")
 
+    def test_wait_for_replication_timeout_propagates(self):
+        with self.store.open_session() as session:
+            session.store(User("Idan", 30), "users/1-A")
+            session.advanced.wait_for_replication_after_save_changes(
+                lambda opts: opts.with_timeout(datetime.timedelta(seconds=5))
+            )
+            batch_options = session._save_changes_options
+            self.assertIsNotNone(batch_options)
+            self.assertIsNotNone(batch_options.replication_options)
+            self.assertEqual(batch_options.replication_options.wait_for_replicas_timeout, datetime.timedelta(seconds=5))
+
+    def test_wait_for_indexes_throw_on_timeout_propagates(self):
+        with self.store.open_session() as session:
+            session.store(User("Idan", 30), "users/1-A")
+            session.advanced.wait_for_indexes_after_save_changes(lambda opts: opts.throw_on_timeout(False))
+            batch_options = session._save_changes_options
+            self.assertIsNotNone(batch_options)
+            self.assertIsNotNone(batch_options.index_options)
+            self.assertIs(batch_options.index_options.throw_on_timeout_in_wait_for_indexes, False)
+
+    def test_wait_for_indexes_specific_indexes_propagates(self):
+        with self.store.open_session() as session:
+            session.store(User("Idan", 30), "users/1-A")
+            session.advanced.wait_for_indexes_after_save_changes(lambda opts: opts.wait_for_indexes(["MyIndex"]))
+            batch_options = session._save_changes_options
+            self.assertIsNotNone(batch_options)
+            self.assertIsNotNone(batch_options.index_options)
+            self.assertIn("MyIndex", batch_options.index_options.wait_for_specific_indexes)
+
+
+class _FakeSession:
+    def __init__(self):
+        self._save_changes_options = None
+
+
+class TestWaitForOptions(unittest.TestCase):
+    def test_replication_timeout_propagates(self):
+        from ravendb.documents.session.document_session_operations.in_memory_document_session_operations import (
+            InMemoryDocumentSessionOperations,
+        )
+
+        session = _FakeSession()
+        builder = InMemoryDocumentSessionOperations.ReplicationWaitOptsBuilder(session)
+        builder.with_timeout(datetime.timedelta(seconds=5))
+        self.assertEqual(
+            session._save_changes_options.replication_options.wait_for_replicas_timeout, datetime.timedelta(seconds=5)
+        )
+
+    def test_indexes_throw_on_timeout_propagates(self):
+        from ravendb.documents.session.document_session_operations.in_memory_document_session_operations import (
+            InMemoryDocumentSessionOperations,
+        )
+
+        session = _FakeSession()
+        builder = InMemoryDocumentSessionOperations.IndexesWaitOptsBuilder(session)
+        builder.throw_on_timeout(False)
+        self.assertIs(session._save_changes_options.index_options.throw_on_timeout_in_wait_for_indexes, False)
+
+    def test_specific_indexes_propagates(self):
+        from ravendb.documents.session.document_session_operations.in_memory_document_session_operations import (
+            InMemoryDocumentSessionOperations,
+        )
+
+        session = _FakeSession()
+        builder = InMemoryDocumentSessionOperations.IndexesWaitOptsBuilder(session)
+        builder.wait_for_indexes(["MyIndex"])
+        self.assertIn("MyIndex", session._save_changes_options.index_options.wait_for_specific_indexes)
+
 
 if __name__ == "__main__":
     unittest.main()