update code to correct code for mocking

Signed-off-by: Hannah Hunter <[email protected]>

Author: hhunter-ms

articles/azure-functions/durable/durable-functions-unit-testing.md

@@ -2,7 +2,7 @@
 title: Azure Durable Functions unit testing
 description: Learn how to unit test Durable Functions.
 ms.topic: conceptual
-ms.date: 11/03/2019
+ms.date: 02/13/2026
 ---
 
 # Durable Functions unit testing (C# in-process)
@@ -42,7 +42,35 @@ These interfaces can be used with the various trigger and bindings supported by
 
 In this section, the unit test validates the logic of the following HTTP trigger function for starting new orchestrations.
 
-[!code-csharp[Main](~/samples-durable-functions/samples/precompiled/HttpStart.cs)]
+```csharp
+using System.Net.Http;
+using System.Threading.Tasks;
+using Microsoft.Azure.WebJobs;
+using Microsoft.Azure.WebJobs.Extensions.DurableTask;
+using Microsoft.Azure.WebJobs.Extensions.Http;
+using Microsoft.Extensions.Logging;
+
+namespace VSSample
+{
+    public static class HttpStart
+    {
+        [FunctionName("HttpStart")]
+        public static async Task<HttpResponseMessage> Run(
+            [HttpTrigger(AuthorizationLevel.Function, "post", Route = "orchestrators/{functionName}")] HttpRequestMessage req,
+            [DurableClient] IDurableClient starter,
+            string functionName,
+            ILogger log)
+        {
+            object eventData = await req.Content.ReadAsAsync<object>();
+            string instanceId = await starter.StartNewAsync(functionName, eventData);
+
+            log.LogInformation($"Started orchestration with ID = '{instanceId}'.");
+
+            return starter.CreateCheckStatusResponse(req, instanceId);
+        }
+    }
+}
+```
 
 The unit test task verifies the value of the `Retry-After` header provided in the response payload. So the unit test mocks some of `IDurableClient` methods to ensure predictable behavior.
 
@@ -65,26 +93,26 @@ durableClientMock.
     ReturnsAsync(instanceId);
 ```
 
-Next `CreateCheckStatusResponse` is mocked to always return an empty HTTP 200 response.
+Next, the test needs to handle `CreateCheckStatusResponse`. Since `CreateCheckStatusResponse` is an extension method, it can't be mocked directly with Moq. Instead, mock the underlying `CreateHttpManagementPayload` method, which is an instance method on `IDurableClient`:
 
 ```csharp
-// Mock CreateCheckStatusResponse method
+// CreateCheckStatusResponse is an extension method and cannot be mocked directly.
+// Mock CreateHttpManagementPayload, which is the underlying instance method.
 durableClientMock
-    // Notice that even though the HttpStart function does not call IDurableClient.CreateCheckStatusResponse() 
-    // with the optional parameter returnInternalServerErrorOnFailure, moq requires the method to be set up
-    // with each of the optional parameters provided. Simply use It.IsAny<> for each optional parameter
-    .Setup(x => x.CreateCheckStatusResponse(It.IsAny<HttpRequestMessage>(), instanceId, returnInternalServerErrorOnFailure: It.IsAny<bool>()))
-    .Returns(new HttpResponseMessage
+    .Setup(x => x.CreateHttpManagementPayload(instanceId))
+    .Returns(new HttpManagementPayload
     {
-        StatusCode = HttpStatusCode.OK,
-        Content = new StringContent(string.Empty),
-        Headers =
-        {
-            RetryAfter = new RetryConditionHeaderValue(TimeSpan.FromSeconds(10))
-        }
+        Id = instanceId,
+        StatusQueryGetUri = $"http://localhost:7071/runtime/webhooks/durabletask/instances/{instanceId}",
+        SendEventPostUri = $"http://localhost:7071/runtime/webhooks/durabletask/instances/{instanceId}/raiseEvent/{{eventName}}",
+        TerminatePostUri = $"http://localhost:7071/runtime/webhooks/durabletask/instances/{instanceId}/terminate",
+        PurgeHistoryDeleteUri = $"http://localhost:7071/runtime/webhooks/durabletask/instances/{instanceId}"
     });
 ```
 
+> [!NOTE]
+> `CreateCheckStatusResponse` is an extension method that internally calls `CreateHttpManagementPayload`. Extension methods are static and cannot be mocked using standard mocking frameworks like Moq. By mocking `CreateHttpManagementPayload`, you control the data used by the extension method.
+
 `ILogger` is also mocked:
 
 ```csharp
@@ -110,24 +138,111 @@ var result = await HttpStart.Run(
  The last step is to compare the output with the expected value:
 
 ```csharp
-// Validate that output is not null
-Assert.NotNull(result.Headers.RetryAfter);
-
-// Validate output's Retry-After header value
-Assert.Equal(TimeSpan.FromSeconds(10), result.Headers.RetryAfter.Delta);
+// Validate the response status code
+Assert.Equal(HttpStatusCode.OK, result.StatusCode);
 ```
 
 After you combine all these steps, the unit test has the following code:
 
-[!code-csharp[Main](~/samples-durable-functions/samples/VSSample.Tests/HttpStartTests.cs)]
+```csharp
+using System;
+using System.Net;
+using System.Net.Http;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.Azure.WebJobs.Extensions.DurableTask;
+using Microsoft.Extensions.Logging;
+using Moq;
+using Xunit;
+
+namespace VSSample.Tests
+{
+    public class HttpStartTests
+    {
+        [Fact]
+        public async Task HttpStart_returns_management_payload()
+        {
+            // Arrange
+            string instanceId = "7E467BDB-213F-407A-B86A-1954053D3C24";
+            string functionName = "E1_HelloSequence";
+
+            var durableClientMock = new Mock<IDurableClient>();
+
+            durableClientMock
+                .Setup(x => x.StartNewAsync(functionName, It.IsAny<object>()))
+                .ReturnsAsync(instanceId);
+
+            // CreateCheckStatusResponse is an extension method and cannot be mocked directly.
+            // Mock CreateHttpManagementPayload, which is the underlying instance method.
+            durableClientMock
+                .Setup(x => x.CreateHttpManagementPayload(instanceId))
+                .Returns(new HttpManagementPayload
+                {
+                    Id = instanceId,
+                    StatusQueryGetUri = $"http://localhost:7071/runtime/webhooks/durabletask/instances/{instanceId}",
+                    SendEventPostUri = $"http://localhost:7071/runtime/webhooks/durabletask/instances/{instanceId}/raiseEvent/{{eventName}}",
+                    TerminatePostUri = $"http://localhost:7071/runtime/webhooks/durabletask/instances/{instanceId}/terminate",
+                    PurgeHistoryDeleteUri = $"http://localhost:7071/runtime/webhooks/durabletask/instances/{instanceId}"
+                });
+
+            var loggerMock = new Mock<ILogger>();
+
+            // Act
+            var result = await HttpStart.Run(
+                new HttpRequestMessage
+                {
+                    Content = new StringContent("{}", Encoding.UTF8, "application/json"),
+                    RequestUri = new Uri("http://localhost:7071/orchestrators/E1_HelloSequence"),
+                },
+                durableClientMock.Object,
+                functionName,
+                loggerMock.Object);
+
+            // Assert
+            Assert.Equal(HttpStatusCode.OK, result.StatusCode);
+        }
+    }
+}
+```
 
 ## Unit testing orchestrator functions
 
 Orchestrator functions are even more interesting for unit testing since they usually have a lot more business logic.
 
 In this section, the unit tests validate the output of the `E1_HelloSequence` Orchestrator function:
 
-[!code-csharp[Main](~/samples-durable-functions/samples/precompiled/HelloSequence.cs)]
+```csharp
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Microsoft.Azure.WebJobs;
+using Microsoft.Azure.WebJobs.Extensions.DurableTask;
+
+namespace VSSample
+{
+    public static class HelloSequence
+    {
+        [FunctionName("E1_HelloSequence")]
+        public static async Task<List<string>> Run(
+            [OrchestrationTrigger] IDurableOrchestrationContext context)
+        {
+            var outputs = new List<string>();
+
+            outputs.Add(await context.CallActivityAsync<string>("E1_SayHello", "Tokyo"));
+            outputs.Add(await context.CallActivityAsync<string>("E1_SayHello", "Seattle"));
+            outputs.Add(await context.CallActivityAsync<string>("E1_SayHello", "London"));
+
+            return outputs;
+        }
+
+        [FunctionName("E1_SayHello")]
+        public static string SayHello([ActivityTrigger] IDurableActivityContext context)
+        {
+            string name = context.GetInput<string>();
+            return $"Hello {name}!";
+        }
+    }
+}
+```
 
 The unit test code starts with creating a mock:
 
@@ -160,19 +275,75 @@ Assert.Equal("Hello London!", result[2]);
 
 After you combine the previous steps, the unit test has the following code:
 
-[!code-csharp[Main](~/samples-durable-functions/samples/VSSample.Tests/HelloSequenceOrchestratorTests.cs)]
+```csharp
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Microsoft.Azure.WebJobs.Extensions.DurableTask;
+using Moq;
+using Xunit;
+
+namespace VSSample.Tests
+{
+    public class HelloSequenceOrchestratorTests
+    {
+        [Fact]
+        public async Task Run_returns_multiple_greetings()
+        {
+            var durableOrchestrationContextMock = new Mock<IDurableOrchestrationContext>();
+            durableOrchestrationContextMock.Setup(x => x.CallActivityAsync<string>("E1_SayHello", "Tokyo")).ReturnsAsync("Hello Tokyo!");
+            durableOrchestrationContextMock.Setup(x => x.CallActivityAsync<string>("E1_SayHello", "Seattle")).ReturnsAsync("Hello Seattle!");
+            durableOrchestrationContextMock.Setup(x => x.CallActivityAsync<string>("E1_SayHello", "London")).ReturnsAsync("Hello London!");
+
+            var result = await HelloSequence.Run(durableOrchestrationContextMock.Object);
+
+            Assert.Equal(3, result.Count);
+            Assert.Equal("Hello Tokyo!", result[0]);
+            Assert.Equal("Hello Seattle!", result[1]);
+            Assert.Equal("Hello London!", result[2]);
+        }
+    }
+}
+```
 
 ## Unit testing activity functions
 
 Activity functions are unit tested in the same way as nondurable functions.
 
 In this section the unit test validates the behavior of the `E1_SayHello` Activity function:
 
-[!code-csharp[Main](~/samples-durable-functions/samples/precompiled/HelloSequence.cs)]
+```csharp
+[FunctionName("E1_SayHello")]
+public static string SayHello([ActivityTrigger] IDurableActivityContext context)
+{
+    string name = context.GetInput<string>();
+    return $"Hello {name}!";
+}
+```
 
 And the unit tests verify the format of the output. These unit tests either use the parameter types directly or mock `IDurableActivityContext` class:
 
-[!code-csharp[Main](~/samples-durable-functions/samples/VSSample.Tests/HelloSequenceActivityTests.cs)]
+```csharp
+using Microsoft.Azure.WebJobs.Extensions.DurableTask;
+using Moq;
+using Xunit;
+
+namespace VSSample.Tests
+{
+    public class HelloSequenceActivityTests
+    {
+        [Fact]
+        public void SayHello_returns_greeting()
+        {
+            var durableActivityContextMock = new Mock<IDurableActivityContext>();
+            durableActivityContextMock.Setup(x => x.GetInput<string>()).Returns("World");
+
+            var result = HelloSequence.SayHello(durableActivityContextMock.Object);
+
+            Assert.Equal("Hello World!", result);
+        }
+    }
+}
+```
 
 ## Next steps