udpate shimdurabletaskclient and test

Author: nytian

src/Client/OrchestrationServiceClientShim/ShimDurableTaskClient.cs

@@ -271,32 +271,28 @@ public override async Task<string> RestartAsync(
             throw new ArgumentException($"An orchestration with the instanceId {instanceId} was not found.");
         }
 
-        // Create options for the new orchestration
-        StartOrchestrationOptions options;
-        if (!restartWithNewInstanceId)
-        {
-            options = new StartOrchestrationOptions()
-            {
-                InstanceId = instanceId,
-            };
-        }
-        else
+        // Determine the instance ID for the restarted orchestration
+        string newInstanceId = restartWithNewInstanceId ? Guid.NewGuid().ToString("N") : instanceId;
+
+        OrchestrationInstance instance = new()
         {
-            options = new StartOrchestrationOptions();
-        }
+            InstanceId = newInstanceId,
+            ExecutionId = Guid.NewGuid().ToString("N"),
+        };
 
-        object? input = null;
-        if (!string.IsNullOrEmpty(status.SerializedInput))
+        // Use the original serialized input directly to avoid double serialization
+        TaskMessage message = new()
         {
-            input = this.DataConverter.Deserialize(status.SerializedInput, typeof(object));
-        }
+            OrchestrationInstance = instance,
+            Event = new ExecutionStartedEvent(-1, status.SerializedInput)
+            {
+                Name = status.Name,
+                OrchestrationInstance = instance,
+            },
+        };
 
-        // Start a new orchestration with the same name and input
-        return await this.ScheduleNewOrchestrationInstanceAsync(
-            new TaskName(status.Name),
-            input,
-            options,
-            cancellation);
+        await this.Client.CreateTaskOrchestrationAsync(message);
+        return newInstanceId;
     }
 
     [return: NotNullIfNotNull("state")]

test/Client/OrchestrationServiceClientShim.Tests/ShimDurableTaskClientTests.cs

@@ -347,9 +347,11 @@ public async Task RestartAsync_EndToEnd(bool restartWithNewInstanceId)
             .Setup(x => x.GetOrchestrationStateAsync(originalInstanceId, false))
             .ReturnsAsync(new List<Core.OrchestrationState> { originalState });
 
-        // Setup the mock for the new orchestration creation
+        // Capture the TaskMessage for verification becasue we will create this message at RestartAsync.
+        TaskMessage? capturedMessage = null;
         this.orchestrationClient
             .Setup(x => x.CreateTaskOrchestrationAsync(It.IsAny<TaskMessage>()))
+            .Callback<TaskMessage>(msg => capturedMessage = msg)
             .Returns(Task.CompletedTask);
 
         string restartedInstanceId = await this.client.RestartAsync(originalInstanceId, restartWithNewInstanceId);
@@ -363,16 +365,21 @@ public async Task RestartAsync_EndToEnd(bool restartWithNewInstanceId)
             restartedInstanceId.Should().Be(originalInstanceId);
         }
 
-        // Verify that CreateTaskOrchestrationAsync was called with the correct parameters
+        // Verify that CreateTaskOrchestrationAsync was called
         this.orchestrationClient.Verify(
-            x => x.CreateTaskOrchestrationAsync(It.Is<TaskMessage>(msg =>
-                msg.Event is ExecutionStartedEvent startedEvent &&
-                startedEvent.Name == orchestratorName &&
-                startedEvent.Input == serializedInput &&
-                (restartWithNewInstanceId ? 
-                    msg.OrchestrationInstance.InstanceId != originalInstanceId :
-                    msg.OrchestrationInstance.InstanceId == originalInstanceId))),
+            x => x.CreateTaskOrchestrationAsync(It.IsAny<TaskMessage>()),
             Times.Once);
+
+        // Verify the captured message details
+        capturedMessage.Should().NotBeNull();
+        capturedMessage!.Event.Should().BeOfType<ExecutionStartedEvent>();
+        
+        var startedEvent = (ExecutionStartedEvent)capturedMessage.Event;
+        startedEvent.Name.Should().Be(orchestratorName);
+        startedEvent.Input.Should().Be(serializedInput);
+        startedEvent.OrchestrationInstance.InstanceId.Should().Be(restartedInstanceId);
+        startedEvent.OrchestrationInstance.ExecutionId.Should().NotBeNullOrEmpty();
+        startedEvent.OrchestrationInstance.ExecutionId.Should().NotBe(originalState.OrchestrationInstance.ExecutionId);
     }
 
     [Fact]