Merge pull request #255 from yh-0/RDBC-954

RDBC-954 Python client: fix Connection String R/W Bugs (OLAP + AI)

Author: poissoncorp

ravendb/documents/operations/ai/ai_connection_string.py

@@ -17,7 +17,7 @@ class AiModelType(enum.Enum):
     CHAT = "Chat"
 
 
-class AiConnectionString(ConnectionString):  # todo kuba
+class AiConnectionString(ConnectionString):
     def __init__(
         self,
         name: str,

ravendb/documents/operations/backups/settings.py

@@ -68,14 +68,20 @@ def __init__(
     def from_json(cls, json_dict: Dict[str, Any]) -> LocalSettings:
         return cls(
             json_dict["Disabled"],
-            GetBackupConfigurationScript.from_json(json_dict["GetBackupConfigurationScript"]),
+            (
+                GetBackupConfigurationScript.from_json(json_dict["GetBackupConfigurationScript"])
+                if json_dict["GetBackupConfigurationScript"]
+                else None
+            ),
             json_dict["FolderPath"],
         )
 
     def to_json(self) -> Dict[str, Any]:
         return {
             "Disabled": self.disabled,
-            "GetBackupConfigurationScript": self.get_backup_configuration_script.to_json(),
+            "GetBackupConfigurationScript": (
+                self.get_backup_configuration_script.to_json() if self.get_backup_configuration_script else None
+            ),
             "FolderPath": self.folder_path,
         }
 

ravendb/documents/operations/connection_string/remove_connection_string_by_name_operation.py

@@ -0,0 +1,57 @@
+import json
+import urllib
+from typing import Dict
+
+import requests
+
+from ravendb import RavenCommand, RaftCommand, ServerNode
+from ravendb.documents.operations.definitions import MaintenanceOperation
+from ravendb.util.util import RaftIdGenerator
+from ravendb.serverwide.server_operation_executor import ConnectionStringType
+
+
+class RemoveConnectionStringByNameResult:
+    def __init__(self, raft_command_index: int = None):
+        self.raft_command_index = raft_command_index
+
+    def to_json(self) -> Dict:
+        return {"RaftCommandIndex": self.raft_command_index}
+
+    @classmethod
+    def from_json(cls, json_dict: Dict) -> "RemoveConnectionStringResult":
+        return cls(json_dict["RaftCommandIndex"])
+
+
+class RemoveConnectionStringByNameOperation(MaintenanceOperation[RemoveConnectionStringByNameResult]):
+    def __init__(self, connection_string_name: str, connection_string_type: ConnectionStringType):
+        self._connection_string_name = connection_string_name
+        self._connection_string_type = connection_string_type
+
+    def get_command(self, conventions: "DocumentConventions") -> "RavenCommand[RemoveConnectionStringResult]":
+        return self.RemoveConnectionStringCommand(self._connection_string_name, self._connection_string_type)
+
+    class RemoveConnectionStringCommand(RavenCommand[RemoveConnectionStringByNameResult], RaftCommand):
+        def __init__(self, connection_string_name: str, connection_string_type: ConnectionStringType):
+            super().__init__(RemoveConnectionStringByNameResult)
+            self._connection_string_name = connection_string_name
+            self._connection_string_type = connection_string_type
+
+        def is_read_request(self) -> bool:
+            return False
+
+        def create_request(self, node: ServerNode) -> requests.Request:
+            url = f"{node.url}/databases/{node.database}/admin/connection-strings?connectionString={urllib.parse.quote(self._connection_string_name)}&type={self._connection_string_type.value}"
+
+            request = requests.Request("DELETE")
+            request.url = url
+
+            return request
+
+        def set_response(self, response: str, from_cache: bool) -> None:
+            if response is None:
+                self._throw_invalid_response()
+
+            self.result = RemoveConnectionStringByNameResult.from_json(json.loads(response))
+
+        def get_raft_unique_request_id(self) -> str:
+            return RaftIdGenerator.new_id()

ravendb/documents/operations/connection_string/remove_connection_string_operation.py

@@ -7,6 +7,7 @@
 from ravendb import RavenCommand, RaftCommand, ConnectionString, ServerNode
 from ravendb.documents.operations.definitions import MaintenanceOperation
 from ravendb.util.util import RaftIdGenerator
+from ravendb.serverwide.server_operation_executor import ConnectionStringType
 
 
 class RemoveConnectionStringResult:
@@ -17,15 +18,15 @@ def to_json(self) -> Dict:
         return {"RaftCommandIndex": self.raft_command_index}
 
     @classmethod
-    def from_json(cls, json_dict: Dict) -> "PutConnectionStringResult":
+    def from_json(cls, json_dict: Dict) -> "RemoveConnectionStringResult":
         return cls(json_dict["RaftCommandIndex"])
 
 
 class RemoveConnectionStringOperation(MaintenanceOperation[RemoveConnectionStringResult]):
     def __init__(self, connection_string: ConnectionString = None):
         self._connection_string = connection_string
 
-    def get_command(self, conventions: "DocumentConventions") -> "RavenCommand[_T]":
+    def get_command(self, conventions: "DocumentConventions") -> "RavenCommand[RemoveConnectionStringResult]":
         return self.RemoveConnectionStringCommand(self._connection_string)
 
     class RemoveConnectionStringCommand(RavenCommand[RemoveConnectionStringResult], RaftCommand):

ravendb/tests/jvm_migrated_tests/client_tests/documents_tests/operations_tests/test_connection_string.py

@@ -18,6 +18,9 @@
 from ravendb.documents.operations.connection_string.put_connection_string_operation import (
     PutConnectionStringOperation,
 )
+from ravendb.documents.operations.connection_string.remove_connection_string_by_name_operation import (
+    RemoveConnectionStringByNameOperation,
+)
 from ravendb.documents.operations.connection_string.remove_connection_string_operation import (
     RemoveConnectionStringOperation,
 )
@@ -1024,3 +1027,23 @@ def test_all_possible_fields_for_each_connection_string_type(self):
             GetConnectionStringsOperation("snowflake_all_fields", ConnectionStringType.SNOWFLAKE)
         )
         self.assertIsNone(after_delete.snowflake_connection_strings)
+
+    def test_remove_connection_string_by_name_operation(self):
+        raven_connection_string = RavenConnectionString("raven1", self.store.database, self.store.urls)
+
+        put_result = self.store.maintenance.send(PutConnectionStringOperation(raven_connection_string))
+        self.assertGreater(put_result.raft_command_index, 0)
+
+        raven_get_result = self.store.maintenance.send(
+            GetConnectionStringsOperation("raven1", ConnectionStringType.RAVEN)
+        )
+        self.assertIn("raven1", raven_get_result.raven_connection_strings)
+        self.assertEqual(1, len(raven_get_result.raven_connection_strings))
+
+        remove_result = self.store.maintenance.send(
+            RemoveConnectionStringByNameOperation("raven1", ConnectionStringType.RAVEN)
+        )
+        self.assertGreater(remove_result.raft_command_index, 0)
+
+        after_delete = self.store.maintenance.send(GetConnectionStringsOperation("raven1", ConnectionStringType.RAVEN))
+        self.assertIsNone(after_delete.raven_connection_strings)