Merge pull request #212 from poissoncorp/RDBC-815

RDBC-815 Make storing dictionaries as collection documents work properly

Author: poissoncorp

ravendb/documents/conventions.py

@@ -32,6 +32,7 @@ def default_conventions(cls):
         return cls()
 
     __cached_default_type_collection_names: Dict[type, str] = {}
+    __cached_keys_collection_names: Dict[str, str] = {}
 
     def __init__(self):
         self._frozen = False
@@ -65,6 +66,7 @@ def __init__(self):
         self._find_identity_property = lambda q: q.__name__ == "key"
         self._find_python_class: Optional[Callable[[str, Dict], str]] = None
         self._find_collection_name: Callable[[Type], str] = self.default_get_collection_name
+        self._find_collection_name_for_dict: Callable[[str], str] = self.default_get_collection_name_for_dict
         self._find_python_class_name: Callable[[Type], str] = (
             lambda object_type: f"{object_type.__module__}.{object_type.__name__}"
         )
@@ -281,6 +283,13 @@ def get_collection_name(self, entity_or_type: Union[type, object]) -> str:
 
         return self.default_get_collection_name(object_type)
 
+    def get_collection_name_for_dict(self, key: str):
+        collection = key.split("/")[0]
+        collection_name = self._find_collection_name_for_dict(collection)
+        if collection_name:
+            return collection_name
+        return self.default_get_collection_name(dict)
+
     def generate_document_id(self, database_name: str, entity: object) -> str:
         object_type = type(entity)
         for list_of_registered_id_convention in self._list_of_registered_id_conventions:
@@ -305,6 +314,16 @@ def default_get_collection_name(object_type: type) -> str:
         DocumentConventions.__cached_default_type_collection_names[object_type] = result
         return result
 
+    @staticmethod
+    def default_get_collection_name_for_dict(key: str) -> str:
+        result = DocumentConventions.__cached_keys_collection_names.get(key, None)
+        if result:
+            return result
+        # singular_noun returns False if the word is singular
+        result = inflector.plural(key) if not inflector.singular_noun(key) else key
+        DocumentConventions.__cached_keys_collection_names[key] = result
+        return result
+
     @staticmethod
     def try_get_type_from_metadata(metadata):
         if "Raven-Python-Type" in metadata:

ravendb/documents/session/document_session_operations/in_memory_document_session_operations.py

@@ -907,7 +907,12 @@ def __store_internal(
 
         self._assert_no_non_unique_instance(entity, key)
 
-        collection_name = self._request_executor.conventions.get_collection_name(entity)
+        collection_name = (
+            self.conventions.get_collection_name_for_dict(key)
+            if entity.__class__ is dict and key and len(key.split("/")) > 1
+            else self._request_executor.conventions.get_collection_name(entity)
+        )
+
         metadata = {}
         if collection_name:
             metadata[constants.Documents.Metadata.COLLECTION] = collection_name

ravendb/tests/issue_tests/test_RDBC_815.py

@@ -0,0 +1,16 @@
+from ravendb.tests.test_base import TestBase
+
+
+class TestRDBC815(TestBase):
+    def setUp(self):
+        super().setUp()
+
+    def test_dict_into_collection(self):
+        with self.store.open_session() as session:
+            session.store({"name": "Gracjan"}, "Drivers/")
+            session.save_changes()
+
+        with self.store.open_session() as session:
+            drivers = list(session.query_collection("Drivers"))
+            self.assertEqual(1, len(drivers))
+            self.assertEqual("Gracjan", drivers[0]["name"])