RDBC-855 Check if pydantic objects break storing documents

RDBC-856 Delete convert_to_snake_case occurances #1/?

Author: poissoncorp

ravendb/documents/commands/batches.py

@@ -199,7 +199,7 @@ def set_response(self, response: str, from_cache: bool) -> None:
                 "Got None response from the server after doing a batch, something is very wrong."
                 " Probably a garbled response."
             )
-        self.result = Utils.initialize_object(json.loads(response), self._result_class, True)
+        self.result = BatchCommandResult.from_json(json.loads(response))
 
 
 class ClusterWideBatchCommand(SingleNodeBatchCommand):

ravendb/documents/operations/operation.py

@@ -51,9 +51,7 @@ def wait_for_completion(self) -> None:
                 raise OperationCancelledException()
             elif operation_status == "Faulted":
                 result = status.get("Result")
-                exception_result: OperationExceptionResult = Utils.initialize_object(
-                    result, OperationExceptionResult, True
-                )
+                exception_result = OperationExceptionResult.from_json(result)
                 schema = ExceptionDispatcher.ExceptionSchema(
                     self.__request_executor.url, exception_result.type, exception_result.message, exception_result.error
                 )

ravendb/documents/session/document_session_operations/in_memory_document_session_operations.py

@@ -599,6 +599,10 @@ def before_query_invoke(self, before_query_event_args: BeforeQueryEventArgs):
     def documents_by_id(self):
         return self._documents_by_id
 
+    @property
+    def included_documents_by_id(self):
+        return self._included_documents_by_id
+
     @property
     def deleted_entities(self):
         return self._deleted_entities

ravendb/documents/session/operations/load_operation.py

@@ -129,11 +129,11 @@ def __get_document(self, object_type: Type[_T], key: str) -> _T:
         if self._session.is_deleted(key):
             return Utils.get_default_value(object_type)
 
-        doc = self._session._documents_by_id.get(key)
+        doc = self._session.documents_by_id.get(key)
         if doc is not None:
             return self._session.track_entity_document_info(object_type, doc)
 
-        doc = self._session._included_documents_by_id.get(key)
+        doc = self._session.included_documents_by_id.get(key)
         if doc is not None:
             return self._session.track_entity_document_info(object_type, doc)
 

ravendb/http/request_executor.py

@@ -438,11 +438,7 @@ def __run(errors: list):
 
             topology = Topology(
                 self._topology_etag,
-                (
-                    self.topology_nodes
-                    if self.topology_nodes
-                    else list(map(lambda url_val: ServerNode(url_val, self._database_name, "!"), initial_urls))
-                ),
+                (self.topology_nodes or [ServerNode(url, self._database_name, "!") for url in initial_urls]),
             )
 
             self._node_selector = NodeSelector(topology, self._thread_pool_executor)

ravendb/http/server_node.py

@@ -1,5 +1,5 @@
 from enum import Enum
-from typing import Optional, TYPE_CHECKING
+from typing import Optional, TYPE_CHECKING, Any, Dict
 
 if TYPE_CHECKING:
     from ravendb.http.topology import ClusterTopology
@@ -26,8 +26,17 @@ def __init__(
         self.database = database
         self.cluster_tag = cluster_tag
         self.server_role = server_role
-        self.__last_server_version_check = 0
-        self.__last_server_version: str = None
+        self._last_server_version_check = 0
+        self._last_server_version: Optional[str] = None
+
+    @classmethod
+    def from_json(cls, json_dict: Dict[str, Any]) -> "ServerNode":
+        return cls(
+            json_dict["Url"],
+            json_dict["Database"],
+            json_dict["ClusterTag"],
+            ServerNode.Role(json_dict["ServerRole"]) if "ServerRole" in json_dict else None,
+        )
 
     def __eq__(self, other) -> bool:
         if self == other:
@@ -45,7 +54,7 @@ def __hash__(self) -> int:
 
     @property
     def last_server_version(self) -> str:
-        return self.__last_server_version
+        return self._last_server_version
 
     @classmethod
     def create_from(cls, topology: "ClusterTopology"):
@@ -64,16 +73,16 @@ def create_from(cls, topology: "ClusterTopology"):
         return nodes
 
     def should_update_server_version(self) -> bool:
-        if self.last_server_version is None or self.__last_server_version_check > 100:
+        if self.last_server_version is None or self._last_server_version_check > 100:
             return True
 
-        self.__last_server_version_check += 1
+        self._last_server_version_check += 1
         return False
 
     def update_server_version(self, server_version: str):
-        self.__last_server_version = server_version
-        self.__last_server_version_check = 0
+        self._last_server_version = server_version
+        self._last_server_version_check = 0
 
     def discard_server_version(self) -> None:
-        self.__last_server_version_check = None
-        self.__last_server_version_check = 0
+        self._last_server_version_check = None
+        self._last_server_version_check = 0

ravendb/http/topology.py

@@ -6,7 +6,7 @@
 import uuid
 from abc import abstractmethod
 from concurrent.futures import ThreadPoolExecutor
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING, Optional, Any
 from typing import Union, List, Dict
 
 from ravendb.exceptions.exceptions import (
@@ -25,6 +25,10 @@ def __init__(self, etag: int, nodes: List[ServerNode]):
         self.etag = etag
         self.nodes = nodes
 
+    @classmethod
+    def from_json(cls, json_dict: Dict[str, Any]) -> "Topology":
+        return cls(json_dict["Etag"], [ServerNode.from_json(node_json_dict) for node_json_dict in json_dict["Nodes"]])
+
 
 class ClusterTopology:
     def __init__(self):

ravendb/json/result.py

@@ -1,10 +1,14 @@
-from typing import List, Any, Dict
+from typing import List, Any, Dict, Optional
 
 
 class BatchCommandResult:
-    def __init__(self, results, transaction_index):
-        self.results: [None, list] = results
-        self.transaction_index: [None, int] = transaction_index
+    def __init__(self, results: Optional[List[Dict]], transaction_index: Optional[int]):
+        self.results = results
+        self.transaction_index = transaction_index
+
+    @classmethod
+    def from_json(cls, json_dict: Dict[str, Any]) -> "BatchCommandResult":
+        return cls(json_dict["Results"], json_dict["TransactionIndex"] if "TransactionIndex" in json_dict else None)
 
 
 class JsonArrayResult:

ravendb/serverwide/commands.py

@@ -13,7 +13,7 @@
 from ravendb.tools.utils import Utils
 
 
-class GetDatabaseTopologyCommand(RavenCommand):
+class GetDatabaseTopologyCommand(RavenCommand[Topology]):
     def __init__(self, debug_tag: Optional[str] = None, application_identifier: Optional[uuid.UUID] = None):
         super().__init__(Topology)
         self.__debug_tag = debug_tag
@@ -33,13 +33,7 @@ def create_request(self, node: ServerNode) -> requests.Request:
     def set_response(self, response: str, from_cache: bool) -> None:
         if response is None:
             return
-
-        # todo: that's pretty bad way to do that, replace with initialization function that take nested object types
-        self.result: Topology = Utils.initialize_object(json.loads(response), self._result_class, True)
-        node_list = []
-        for node in self.result.nodes:
-            node_list.append(Utils.initialize_object(node, ServerNode, True))
-        self.result.nodes = node_list
+        self.result = Topology.from_json(json.loads(response))
 
 
 class GetClusterTopologyCommand(RavenCommand[ClusterTopologyResponse]):

ravendb/tests/issue_tests/test_RDBC_855.py

@@ -0,0 +1,22 @@
+from datetime import datetime
+
+from pydantic import BaseModel
+
+from ravendb.tests.test_base import TestBase
+
+
+class User(BaseModel):
+    name: str = None
+    birthday: datetime = None
+    Id: str = None
+
+
+class TestRDBC855(TestBase):
+    def test_storing_pydantic_objects(self):
+        with self.store.open_session() as session:
+            session.store(User(name="Josh", birthday=datetime(1999, 1, 1), Id="users/51"))
+            session.save_changes()
+
+        with self.store.open_session() as session:
+            user = session.load("users/51", User)
+            self.assertEqual("Josh", user.name)