Test that a non-positive signature cache bound is clamped

_EntityMethodSignatureCache clamps its bound with max(1, max_size), but
nothing covered that clamp, so the PR description overstated the test
coverage. Add regression tests for it.

The clamp is not cosmetic. Without it a bound of 0 evicts each entry
immediately after inserting it, so every lookup misses and the entity
method reflection this cache exists to avoid runs on every operation
again -- silently reintroducing the very problem this change fixes. A
negative bound is worse: the eviction loop keeps popping past an
already-empty dict and raises StopIteration.

The new tests cover a zero and negative bound, that a clamped cache
still behaves as a working size-one cache rather than a no-op, and that
an executor handed a clamped cache still reflects only once. Verified
red before green: with the clamp removed all five fail, including
'assert 3 == 1' on the reflection count.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Copilot-Session: 2265f7b9-f8ad-4b50-a25d-19bd6f1ac96c

Author: Bernd Verst

tests/durabletask/test_entity_executor.py

@@ -7,6 +7,7 @@
 import logging
 import threading
 
+import pytest
 from google.protobuf import wrappers_pb2
 
 import durabletask.internal.orchestrator_service_pb2 as pb
@@ -523,3 +524,57 @@ def writer(worker_index: int) -> None:
             thread.join()
 
         assert len(cache) == 8
+
+    @pytest.mark.parametrize("max_size", [0, -1, -1024])
+    def test_non_positive_max_size_is_clamped_to_one(self, max_size: int):
+        """A non-positive bound must not produce a zero-capacity cache.
+
+        Without clamping, a bound of 0 would evict every entry immediately
+        after inserting it, so every lookup would miss and the signature
+        reflection this cache exists to avoid would run on every operation
+        again. A negative bound is worse still: the eviction loop would keep
+        popping past an already-empty dict.
+        """
+        cache = _EntityMethodSignatureCache(max_size=max_size)
+
+        cache[(int, "op")] = True
+
+        assert len(cache) == 1
+        assert cache.get((int, "op")) is True
+        assert (int, "op") in cache
+
+    def test_clamped_cache_still_evicts_and_serves_hits(self):
+        """A clamped cache behaves as a working size-1 cache, not a no-op."""
+        cache = _EntityMethodSignatureCache(max_size=0)
+
+        cache[(int, "op")] = True
+        cache[(str, "op")] = False
+
+        # The newest entry is retained and readable; the older one is evicted
+        # because the effective bound is one, not because caching is disabled.
+        assert len(cache) == 1
+        assert cache.get((str, "op")) is False
+        assert cache.get((int, "op")) is None
+
+    def test_executor_with_clamped_cache_still_caches_reflection(self, monkeypatch):
+        """An executor handed a clamped cache must still avoid re-reflecting."""
+        counting = _CountingInspect()
+        monkeypatch.setattr(worker, "inspect", counting)
+
+        registry = _Registry()
+        registry.add_entity(Counter)
+        executor = _EntityExecutor(
+            registry,
+            logging.getLogger("test"),
+            JsonDataConverter(),
+            entity_method_cache=_EntityMethodSignatureCache(max_size=0),
+        )
+
+        entity_id = entities.EntityInstanceId("Counter", "test-key")
+        state = StateShim(None, JsonDataConverter())
+        for _ in range(3):
+            executor.execute("test-orch", entity_id, "add", state, "1")
+            state.commit()
+
+        assert len(counting.signature_calls) == 1
+        assert state.get_state(int) == 3