feedback

Author: YunchuWang

src/Client/Grpc/ProtoUtils.cs

@@ -40,10 +40,10 @@ public static class ProtoUtils
     /// So replaceableStatus = all terminal statuses MINUS dedupeStatuses.
     /// </remarks>
     public static P.OrchestrationIdReusePolicy? ConvertDedupeStatusesToReusePolicy(
-        IEnumerable<P.OrchestrationStatus> dedupeStatuses)
+        IEnumerable<P.OrchestrationStatus>? dedupeStatuses)
     {
         ImmutableArray<P.OrchestrationStatus> terminalStatuses = GetTerminalStatuses();
-        ImmutableHashSet<P.OrchestrationStatus> dedupeStatusSet = dedupeStatuses.ToImmutableHashSet();
+        ImmutableHashSet<P.OrchestrationStatus> dedupeStatusSet = dedupeStatuses?.ToImmutableHashSet() ?? ImmutableHashSet<P.OrchestrationStatus>.Empty;
 
         P.OrchestrationIdReusePolicy policy = new();
 

src/Client/OrchestrationServiceClientShim/ShimDurableTaskClient.cs

@@ -201,10 +201,8 @@ public override async Task<string> ScheduleNewOrchestrationInstanceAsync(
                 {
                     if (!Enum.TryParse<OrchestrationRuntimeStatus>(s, ignoreCase: true, out var status))
                     {
-                        var validStatuses = string.Join(", ", Enum.GetNames(typeof(OrchestrationRuntimeStatus)));
                         throw new ArgumentException(
-                            $"Invalid orchestration runtime status: '{s}' for deduplication. Valid values are: {validStatuses}",
-                            nameof(options.DedupeStatuses));
+                            $"Invalid orchestration runtime status: '{s}' for deduplication.");
                     }
                     return status.ConvertToCore();
                 })

test/Client/Grpc.Tests/GrpcDurableTaskClientTests.cs

@@ -0,0 +1,131 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using Grpc.Core;
+using Microsoft.DurableTask.Client;
+using Microsoft.Extensions.Logging;
+
+namespace Microsoft.DurableTask.Client.Grpc.Tests;
+
+public class GrpcDurableTaskClientTests
+{
+    readonly Mock<ILogger> loggerMock = new();
+
+    GrpcDurableTaskClient CreateClient()
+    {
+        var callInvoker = Mock.Of<CallInvoker>();
+        var options = new GrpcDurableTaskClientOptions
+        {
+            CallInvoker = callInvoker,
+        };
+
+        return new GrpcDurableTaskClient("test", options, this.loggerMock.Object);
+    }
+
+    [Fact]
+    public async Task ScheduleNewOrchestrationInstanceAsync_InvalidDedupeStatus_ThrowsArgumentException()
+    {
+        // Arrange
+        var client = this.CreateClient();
+        var startOptions = new StartOrchestrationOptions
+        {
+            DedupeStatuses = new[] { "InvalidStatus", "AnotherInvalidStatus" },
+        };
+
+        // Act & Assert
+        Func<Task> act = async () => await client.ScheduleNewOrchestrationInstanceAsync(
+            new TaskName("TestOrchestration"),
+            input: null,
+            startOptions);
+
+        var exception = await act.Should().ThrowAsync<ArgumentException>();
+        exception.Which.Message.Should().Contain("Invalid orchestration runtime status: 'InvalidStatus' for deduplication.");
+    }
+
+    [Fact]
+    public async Task ScheduleNewOrchestrationInstanceAsync_InvalidDedupeStatus_ContainsInvalidStatusInMessage()
+    {
+        // Arrange
+        var client = this.CreateClient();
+        var startOptions = new StartOrchestrationOptions
+        {
+            DedupeStatuses = new[] { "NonExistentStatus" },
+        };
+
+        // Act & Assert
+        Func<Task> act = async () => await client.ScheduleNewOrchestrationInstanceAsync(
+            new TaskName("TestOrchestration"),
+            input: null,
+            startOptions);
+
+        var exception = await act.Should().ThrowAsync<ArgumentException>();
+        exception.Which.Message.Should().Contain("'NonExistentStatus'");
+        exception.Which.Message.Should().Contain("for deduplication");
+    }
+
+    [Fact]
+    public async Task ScheduleNewOrchestrationInstanceAsync_MixedValidAndInvalidStatus_ThrowsArgumentException()
+    {
+        // Arrange
+        var client = this.CreateClient();
+        var startOptions = new StartOrchestrationOptions
+        {
+            DedupeStatuses = new[] { "Completed", "InvalidStatus", "Failed" },
+        };
+
+        // Act & Assert
+        Func<Task> act = async () => await client.ScheduleNewOrchestrationInstanceAsync(
+            new TaskName("TestOrchestration"),
+            input: null,
+            startOptions);
+
+        var exception = await act.Should().ThrowAsync<ArgumentException>();
+        exception.Which.Message.Should().Contain("Invalid orchestration runtime status: 'InvalidStatus' for deduplication.");
+    }
+
+    [Fact]
+    public async Task ScheduleNewOrchestrationInstanceAsync_CaseInsensitiveValidStatus_DoesNotThrowArgumentException()
+    {
+        // Arrange
+        var client = this.CreateClient();
+        var startOptions = new StartOrchestrationOptions
+        {
+            DedupeStatuses = new[] { "completed", "FAILED", "Terminated" },
+        };
+
+        // Act & Assert - Case-insensitive parsing should work, so no ArgumentException should be thrown
+        // The call will fail at the gRPC level, but validation should pass
+        Func<Task> act = async () => await client.ScheduleNewOrchestrationInstanceAsync(
+            new TaskName("TestOrchestration"),
+            input: null,
+            startOptions);
+
+        // Should not throw ArgumentException for invalid status (case-insensitive parsing works)
+        // It may throw other exceptions due to gRPC call failure, but not ArgumentException
+        var exception = await act.Should().ThrowAsync<Exception>();
+        exception.Which.Should().NotBeOfType<ArgumentException>();
+    }
+
+    [Fact]
+    public async Task ScheduleNewOrchestrationInstanceAsync_ValidDedupeStatus_DoesNotThrowArgumentException()
+    {
+        // Arrange
+        var client = this.CreateClient();
+        var startOptions = new StartOrchestrationOptions
+        {
+            DedupeStatuses = new[] { "Completed", "Failed" },
+        };
+
+        // Act & Assert - Valid statuses should pass validation
+        // The call will fail at the gRPC level, but validation should pass
+        Func<Task> act = async () => await client.ScheduleNewOrchestrationInstanceAsync(
+            new TaskName("TestOrchestration"),
+            input: null,
+            startOptions);
+
+        // Should not throw ArgumentException for invalid status since "Completed" and "Failed" are valid
+        var exception = await act.Should().ThrowAsync<Exception>();
+        exception.Which.Should().NotBeOfType<ArgumentException>();
+    }
+}
+