RDBC-1048 Fix cluster transaction validation, compare exchange state checks, and batch patch status handling

Author: redknightlois

ravendb/documents/operations/batch.py

@@ -190,7 +190,7 @@ def _handle_patch(self, batch_result: dict) -> None:
             self._throw_missing_field(CommandType.PATCH, "PatchStatus")
 
         status = PatchStatus(patch_status)
-        if status == PatchStatus.CREATED or PatchStatus.PATCHED:
+        if status in (PatchStatus.CREATED, PatchStatus.PATCHED):
             document = batch_result.get("ModifiedDocument")
             if not document:
                 return

ravendb/documents/operations/compare_exchange/compare_exchange.py

@@ -133,7 +133,7 @@ def delete(self, index: int) -> None:
         self._state = CompareExchangeValueState.DELETED
 
     def __assert_state(self) -> None:
-        if self._state == CompareExchangeValueState.NONE or CompareExchangeValueState.MISSING:
+        if self._state in (CompareExchangeValueState.NONE, CompareExchangeValueState.MISSING):
             return
         elif self._state == CompareExchangeValueState.CREATED:
             raise RuntimeError(f"The compare exchange value with key {self._key} was already stored.")
@@ -144,7 +144,7 @@ def get_command(
         self, conventions: DocumentConventions
     ) -> Optional[Union[DeleteCompareExchangeCommandData, PutCompareExchangeCommandData]]:
         s = self._state
-        if s == CompareExchangeValueState.NONE or CompareExchangeValueState.CREATED:
+        if s in (CompareExchangeValueState.NONE, CompareExchangeValueState.CREATED):
             if not self.__value:
                 return None
 

ravendb/documents/session/document_session_operations/in_memory_document_session_operations.py

@@ -985,13 +985,13 @@ def validate_cluster_transaction(self, result: SaveChangesData) -> None:
             )
 
         for command_data in result.session_commands:
-            if command_data.command_type == CommandType.PUT or CommandType.DELETE:
+            if command_data.command_type in (CommandType.PUT, CommandType.DELETE):
                 if command_data.change_vector is not None:
                     raise ValueError(
                         f"Optimistic concurrency for {command_data.key} "
                         f"is not supported when using a cluster transaction"
                     )
-            elif command_data.command_type == CommandType.COMPARE_EXCHANGE_DELETE or CommandType.COMPARE_EXCHANGE_PUT:
+            elif command_data.command_type in (CommandType.COMPARE_EXCHANGE_DELETE, CommandType.COMPARE_EXCHANGE_PUT):
                 pass
             else:
                 raise ValueError(f"The command '{command_data.command_type}' is not supported in a cluster session.")

ravendb/tests/jvm_migrated_tests/cluster_tests/test_cluster_transaction.py

@@ -1,3 +1,7 @@
+import unittest
+
+from ravendb.documents.commands.batches import CommandType, CountersBatchCommandData
+from ravendb.documents.operations.counters import CounterOperation, CounterOperationType
 from ravendb.documents.session.misc import SessionOptions, TransactionMode
 from ravendb.infrastructure.entities import User
 from ravendb.tests.test_base import TestBase
@@ -74,3 +78,64 @@ def test_session_sequence(self):
             user1.age = 10
             session.store(user1, "users/1")
             session.save_changes()
+
+    def test_throw_on_unsupported_operations(self):
+        session_options = SessionOptions(
+            transaction_mode=TransactionMode.CLUSTER_WIDE,
+            disable_atomic_document_writes_in_cluster_wide_transaction=True,
+        )
+
+        with self.store.open_session(session_options=session_options) as session:
+            from ravendb.documents.session.document_session_operations.in_memory_document_session_operations import (
+                InMemoryDocumentSessionOperations,
+            )
+
+            counter_op = CounterOperation("likes", CounterOperationType.INCREMENT, 1)
+            counter_cmd = CountersBatchCommandData("docs/1", counter_op)
+
+            save_changes_data = InMemoryDocumentSessionOperations.SaveChangesData(session)
+            save_changes_data.session_commands.append(counter_cmd)
+
+            with self.assertRaises(ValueError) as ctx:
+                session.validate_cluster_transaction(save_changes_data)
+
+            self.assertIn("not supported", str(ctx.exception))
+
+    def test_compare_exchange_double_create_raises(self):
+        session_options = SessionOptions(
+            transaction_mode=TransactionMode.CLUSTER_WIDE,
+            disable_atomic_document_writes_in_cluster_wide_transaction=True,
+        )
+
+        with self.store.open_session(session_options=session_options) as session:
+            session.advanced.cluster_transaction.create_compare_exchange_value("users/emails/john", "john@doe.com")
+
+            with self.assertRaises(RuntimeError):
+                session.advanced.cluster_transaction.create_compare_exchange_value("users/emails/john", "other@doe.com")
+
+
+class TestClusterTransactionValidation(unittest.TestCase):
+    def test_cluster_tx_rejects_unsupported_command_types(self):
+        import inspect
+        from ravendb.documents.session.document_session_operations.in_memory_document_session_operations import (
+            InMemoryDocumentSessionOperations,
+        )
+
+        src = inspect.getsource(InMemoryDocumentSessionOperations.validate_cluster_transaction)
+        self.assertNotIn(
+            "== CommandType.PUT or CommandType.DELETE",
+            src,
+            "Cluster TX validation uses 'x == A or B' (always True). Must use 'x in (A, B)'.",
+        )
+
+    def test_compare_exchange_rejects_double_create(self):
+        from ravendb.documents.operations.compare_exchange.compare_exchange import (
+            CompareExchangeSessionValue,
+            CompareExchangeValueState,
+        )
+
+        value = CompareExchangeSessionValue.__new__(CompareExchangeSessionValue)
+        value._key = "test"
+        value._state = CompareExchangeValueState.CREATED
+        with self.assertRaises(RuntimeError):
+            value._CompareExchangeSessionValue__assert_state()