Reject conflicting Functions registrations

Keep repeated invocation idempotent only for the original callable and preserve duplicate-registration errors when a shared worker receives a different function with the same name.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Copilot-Session: b29a8f40-77ba-48d9-a3f7-2748491f3791

Author: andystaples

azure-functions-durable/azure/durable_functions/worker.py

@@ -43,6 +43,12 @@ def __init__(self) -> None:
         # the wire format the Durable Functions host extension expects.
         super().__init__(data_converter=DEFAULT_FUNCTIONS_DATA_CONVERTER)
         self._registration_lock = Lock()
+        self._registered_orchestrator_functions: dict[
+            str, task.Orchestrator[Any, Any]
+        ] = {}
+        self._registered_entity_functions: dict[
+            str, task.Entity[Any, Any]
+        ] = {}
 
     def add_named_orchestrator(self, name: str, func: task.Orchestrator[Any, Any]) -> None:
         self._registry.add_named_orchestrator(name, func)
@@ -53,14 +59,22 @@ def _register_orchestrator_once(
             func: task.Orchestrator[Any, Any],
     ) -> None:
         with self._registration_lock:
-            if self._registry.get_orchestrator(name) is None:
-                self.add_named_orchestrator(name, wrap_orchestrator(func))
+            if self._registered_orchestrator_functions.get(name) is func:
+                return
+            if self._registry.get_orchestrator(name) is not None:
+                raise ValueError(f"A '{name}' orchestrator already exists.")
+            self.add_named_orchestrator(name, wrap_orchestrator(func))
+            self._registered_orchestrator_functions[name] = func
 
     def _register_entity_once(self, func: task.Entity[Any, Any]) -> None:
         name = task.get_entity_name(func).lower()
         with self._registration_lock:
-            if self._registry.get_entity(name) is None:
-                self.add_entity(wrap_entity(func), name=name)
+            if self._registered_entity_functions.get(name) is func:
+                return
+            if self._registry.get_entity(name) is not None:
+                raise ValueError(f"A '{name}' entity already exists.")
+            self.add_entity(wrap_entity(func), name=name)
+            self._registered_entity_functions[name] = func
 
     def execute_orchestration_request(self, func: task.Orchestrator[Any, Any], context: Any) -> str:
         context_body = getattr(context, "body", None)

tests/azure-functions-durable/test_worker_compat.py

@@ -151,6 +151,21 @@ def orchestrator(context):
     )
 
 
+def test_execute_orchestration_request_rejects_different_function_with_same_name():
+    def first_orchestrator(context):
+        return "first"
+
+    def second_orchestrator(context):
+        return "second"
+
+    worker = DurableFunctionsWorker()
+    encoded = _encode_orchestrator_request("same-name")
+    worker.execute_orchestration_request(first_orchestrator, encoded)
+
+    with pytest.raises(ValueError, match="A 'same-name' orchestrator already exists"):
+        worker.execute_orchestration_request(second_orchestrator, encoded)
+
+
 # ---------------------------------------------------------------------------
 # execute_entity_batch_request
 # ---------------------------------------------------------------------------
@@ -237,3 +252,20 @@ def entity(context):
             result).results[0].success.result.value) == "handled"
         for result in results
     )
+
+
+def test_execute_entity_batch_request_rejects_different_function_with_same_name():
+    def first_entity(context):
+        context.set_result("first")
+
+    def second_entity(context):
+        context.set_result("second")
+
+    first_entity.__durable_entity_name__ = "Counter"
+    second_entity.__durable_entity_name__ = "Counter"
+    worker = DurableFunctionsWorker()
+    encoded = _encode_entity_batch_request("@counter@key1", "op")
+    worker.execute_entity_batch_request(first_entity, encoded)
+
+    with pytest.raises(ValueError, match="A 'counter' entity already exists"):
+        worker.execute_entity_batch_request(second_entity, encoded)