RDBC-1030: normalize Enum dict keys in Utils.entity_to_dict

json.dumps raises TypeError for non-string dict keys. Entities whose fields are dicts with Enum keys (e.g. {CheckType.ENGINE: CheckStatus.GOOD}) failed at session.store() time. Fix: wrap default_method to recursively convert Enum keys to their .value before json.dumps sees them.

Regression test: test_store_enum_key_dict.py verifies that an entity with an Enum-keyed dict field stores and round-trips correctly.

Author: redknightlois

ravendb/tests/documents_tests/test_store_enum_key_dict.py

@@ -0,0 +1,79 @@
+"""
+Serialization: entities whose dict fields use Enum keys store and round-trip
+correctly; Enum keys are serialized as their string values.
+
+C# reference: FastTests/Issues/RavenDB_22084.cs
+  StoreOnDictionaryWithEnumKeyShouldWork
+"""
+
+from enum import Enum
+
+from ravendb.tests.test_base import TestBase
+
+
+class CheckType(Enum):
+    ENGINE = "Engine"
+    GEARS = "Gears"
+
+
+class CheckStatus(Enum):
+    GOOD = "Good"
+    BAD = "Bad"
+
+
+class Machine:
+    def __init__(self, checks=None):
+        self.checks = checks or {}
+
+
+class TestRavenDB22084(TestBase):
+    def setUp(self):
+        super().setUp()
+
+    def test_store_entity_with_enum_keyed_dict(self):
+        """
+        C# spec: StoreOnDictionaryWithEnumKeyShouldWork
+          var m = new Machine { Checks = { [CheckType.Engine] = CheckStatus.Good, ... } }
+          session.Store(m)
+          session.SaveChanges()  → succeeds; Enum keys are serialized as their string values.
+        """
+        m = Machine(checks={CheckType.ENGINE: CheckStatus.GOOD, CheckType.GEARS: CheckStatus.GOOD})
+        with self.store.open_session() as session:
+            session.store(m, "machines/1")
+            session.save_changes()
+
+    def test_round_trip_preserves_enum_dict_values(self):
+        """
+        C# spec: after StoreOnDictionaryWithEnumKeyShouldWork, loading the document back
+        gives Checks[CheckType.Engine] == CheckStatus.Good.
+        """
+        m = Machine(checks={CheckType.ENGINE: CheckStatus.GOOD, CheckType.GEARS: CheckStatus.BAD})
+        with self.store.open_session() as session:
+            session.store(m, "machines/2")
+            session.save_changes()
+
+        with self.store.open_session() as session:
+            loaded = session.load("machines/2", Machine)
+            self.assertIsNotNone(loaded, "Document should be loadable after store")
+            # JSON deserializes back to string keys; verify the enum values were stored correctly.
+            self.assertEqual("Good", loaded.checks.get("Engine"), "Engine check should be Good")
+            self.assertEqual("Bad", loaded.checks.get("Gears"), "Gears check should be Bad")
+
+    # ------------------------------------------------------------------ #
+    #  Baseline: dict with string keys                                    #
+    # ------------------------------------------------------------------ #
+
+    def test_store_entity_with_string_keyed_dict_works(self):
+        """
+        Baseline: when dict keys are plain strings, store() works without error.
+        Confirms the serialization layer itself is functional.
+        """
+        m = Machine(checks={"Engine": "Good", "Gears": "Good"})
+        with self.store.open_session() as session:
+            session.store(m, "machines/3")
+            session.save_changes()
+
+        with self.store.open_session() as session:
+            loaded = session.load("machines/3", Machine)
+            self.assertIsNotNone(loaded)
+            self.assertEqual(2, len(loaded.checks))

ravendb/tools/utils.py

@@ -942,7 +942,19 @@ def dictionarize(obj: object) -> dict:
 
     @staticmethod
     def entity_to_dict(entity, default_method) -> dict:
-        return json.loads(json.dumps(entity, default=default_method))
+        def _normalize_enum_keys(obj):
+            """Recursively convert Enum dict keys to their values so json.dumps accepts them."""
+            if isinstance(obj, dict):
+                return {(k.value if isinstance(k, Enum) else k): _normalize_enum_keys(v) for k, v in obj.items()}
+            if isinstance(obj, (list, set, tuple)):
+                return [_normalize_enum_keys(i) for i in obj]
+            return obj
+
+        def _normalized_default(o):
+            result = default_method(o)
+            return _normalize_enum_keys(result)
+
+        return json.loads(json.dumps(entity, default=_normalized_default))
 
     @staticmethod
     def add_hours(date: datetime, hours: int):