add deterministic tests, use dotnet version for uuid

Signed-off-by: Filinto Duran <[email protected]>

Author: filintod

durabletask/deterministic.py

@@ -52,14 +52,45 @@ def deterministic_random(instance_id: str, orchestration_time: datetime) -> rand
 
 
 def deterministic_uuid4(rnd: random.Random) -> uuid.UUID:
-    """Generate a deterministic UUID4 using the provided random generator."""
+    """
+    Generate a deterministic UUID4 using the provided random generator.
+
+    Note: This is deprecated in favor of deterministic_uuid_v5 which matches
+    the .NET implementation for cross-language compatibility.
+    """
     bytes_ = bytes(rnd.randrange(0, 256) for _ in range(16))
     bytes_list = list(bytes_)
     bytes_list[6] = (bytes_list[6] & 0x0F) | 0x40  # Version 4
     bytes_list[8] = (bytes_list[8] & 0x3F) | 0x80  # Variant bits
     return uuid.UUID(bytes=bytes(bytes_list))
 
 
+def deterministic_uuid_v5(instance_id: str, current_datetime: datetime, counter: int) -> uuid.UUID:
+    """
+    Generate a deterministic UUID v5 matching the .NET implementation.
+
+    This implementation matches the durabletask-dotnet NewGuid() method:
+    https://github.com/microsoft/durabletask-dotnet/blob/main/src/Worker/Core/Shims/TaskOrchestrationContextWrapper.cs
+
+    Args:
+        instance_id: The orchestration instance ID.
+        current_datetime: The current orchestration datetime (frozen during replay).
+        counter: The per-call counter (starts at 0 on each replay).
+
+    Returns:
+        A deterministic UUID v5 that will be the same across replays.
+    """
+    # DNS namespace UUID - same as .NET DnsNamespaceValue
+    namespace = uuid.UUID("9e952958-5e33-4daf-827f-2fa12937b875")
+
+    # Build name matching .NET format: instanceId_datetime_counter
+    # Using isoformat() which produces ISO 8601 format similar to .NET's ToString("o")
+    name = f"{instance_id}_{current_datetime.isoformat()}_{counter}"
+
+    # Generate UUID v5 (SHA-1 based, matching .NET)
+    return uuid.uuid5(namespace, name)
+
+
 @runtime_checkable
 class DeterministicContextProtocol(Protocol):
     """Protocol for contexts that provide deterministic operations."""
@@ -76,8 +107,18 @@ class DeterministicContextMixin:
     Mixin providing deterministic helpers for workflow contexts.
 
     Assumes the inheriting class exposes `instance_id` and `current_utc_datetime` attributes.
+
+    This implementation matches the .NET durabletask SDK approach with an explicit
+    counter for UUID generation that resets on each replay.
     """
 
+    def __init__(self, *args, **kwargs):
+        """Initialize the mixin with a UUID counter."""
+        super().__init__(*args, **kwargs)
+        # Counter for deterministic UUID generation (matches .NET newGuidCounter)
+        # This counter resets to 0 on each replay, ensuring determinism
+        self._uuid_counter: int = 0
+
     def now(self) -> datetime:
         """Return orchestration time (deterministic UTC)."""
         value = self.current_utc_datetime  # type: ignore[attr-defined]
@@ -98,9 +139,29 @@ def random(self) -> random.Random:
         return rnd
 
     def uuid4(self) -> uuid.UUID:
-        """Return a deterministically generated UUID using the deterministic PRNG."""
-        rnd = self.random()
-        return deterministic_uuid4(rnd)
+        """
+        Return a deterministically generated UUID v5 with explicit counter.
+        https://www.sohamkamani.com/uuid-versions-explained/#v5-non-random-uuids
+
+        This matches the .NET implementation's NewGuid() method which uses:
+        - Instance ID
+        - Current UTC datetime (frozen during replay)
+        - Per-call counter (resets to 0 on each replay)
+
+        The counter ensures multiple calls produce different UUIDs while maintaining
+        determinism across replays.
+        """
+        # Lazily initialize counter if not set by __init__ (for compatibility)
+        if not hasattr(self, "_uuid_counter"):
+            self._uuid_counter = 0
+
+        result = deterministic_uuid_v5(
+            self.instance_id,  # type: ignore[attr-defined]
+            self.current_utc_datetime,  # type: ignore[attr-defined]
+            self._uuid_counter,
+        )
+        self._uuid_counter += 1
+        return result
 
     def new_guid(self) -> uuid.UUID:
         """Alias for uuid4 for API parity with other SDKs."""