PR Feedback

Author: andystaples

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

@@ -7,7 +7,7 @@ ms.date: 05/07/2025
 ms.author: azfuncdf
 ---
 
-# Unit Testing Durable Functions in Python
+# Unit testing Durable Functions in Python
 
 Unit testing is an important part of modern software development practices. Unit tests verify business logic behavior and protect from introducing unnoticed breaking changes in the future. Durable Functions can easily grow in complexity so introducing unit tests helps avoid breaking changes. The following sections explain how to unit test the three function types - Orchestration client, orchestrator, and entity functions.
 
@@ -23,7 +23,7 @@ The examples in this article require knowledge of the following concepts and fra
 * Python [unittest](https://docs.python.org/3/library/unittest.html) 
 * [unittest.mock](https://docs.python.org/3/library/unittest.mock.html)
 
-## Setting Up the Test Environment
+## Setting up the test environment
 
 To test Durable Functions, it's crucial to set up a proper test environment. This includes creating a test directory and installing Python's `unittest` module into your Python environment. For more info, see the [Azure Functions Python unit testing overview](../functions-reference-python.md#unit-testing).
 

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

@@ -28,23 +28,23 @@ The examples in this article require knowledge of the following concepts and fra
 
 Mocking is supported via the following interface:
 
-* [IDurableOrchestrationClient](/dotnet/api/microsoft.azure.webjobs.extensions.durabletask.idurableorchestrationclient), [IDurableEntityClient](/dotnet/api/microsoft.azure.webjobs.extensions.durabletask.idurableentityclient) and [IDurableClient](/dotnet/api/microsoft.azure.webjobs.extensions.durabletask.idurableclient)
+* [IDurableOrchestrationClient](/dotnet/api/microsoft.azure.webjobs.extensions.durabletask.idurableorchestrationclient), [IDurableEntityClient](/dotnet/api/microsoft.azure.webjobs.extensions.durabletask.idurableentityclient), and [IDurableClient](/dotnet/api/microsoft.azure.webjobs.extensions.durabletask.idurableclient)
 
 * [IDurableOrchestrationContext](/dotnet/api/microsoft.azure.webjobs.extensions.durabletask.idurableorchestrationcontext)
 
 * [IDurableActivityContext](/dotnet/api/microsoft.azure.webjobs.extensions.durabletask.idurableactivitycontext)
 
 * [IDurableEntityContext](/dotnet/api/microsoft.azure.webjobs.extensions.durabletask.idurableentitycontext)
 
-These interfaces can be used with the various trigger and bindings supported by Durable Functions. When executing your Azure Functions, the functions runtime will run your function code with a concrete implementation of these interfaces. For unit testing, you can pass in a mocked version of these interfaces to test your business logic.
+These interfaces can be used with the various trigger and bindings supported by Durable Functions. While it is executing your Azure Functions, the functions runtime runs your function code with a concrete implementation of these interfaces. For unit testing, you can pass in a mocked version of these interfaces to test your business logic.
 
 ## Unit testing trigger functions
 
-In this section, the unit test will validate the logic of the following HTTP trigger function for starting new orchestrations.
+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)]
 
-The unit test task will be to verify the value of the `Retry-After` header provided in the response payload. So the unit test will mock some of `IDurableClient` methods to ensure predictable behavior.
+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.
 
 First, we use a mocking framework ([moq](https://github.com/moq/moq4) in this case) to mock `IDurableClient`:
 
@@ -54,7 +54,7 @@ var durableClientMock = new Mock<IDurableClient>();
 ```
 
 > [!NOTE]
-> While you can mock interfaces by directly implementing the interface as a class, mocking frameworks simplify the process in various ways. For instance, if a new method is added to the interface across minor releases, moq will not require any code changes unlike concrete implementations.
+> While you can mock interfaces by directly implementing the interface as a class, mocking frameworks simplify the process in various ways. For instance, if a new method is added to the interface across minor releases, moq doesn't require any code changes unlike concrete implementations.
 
 Then `StartNewAsync` method is mocked to return a well-known instance ID.
 
@@ -117,39 +117,39 @@ Assert.NotNull(result.Headers.RetryAfter);
 Assert.Equal(TimeSpan.FromSeconds(10), result.Headers.RetryAfter.Delta);
 ```
 
-After combining all steps, the unit test will have the following code:
+After you combine all these steps, the unit test has the following code:
 
 [!code-csharp[Main](~/samples-durable-functions/samples/VSSample.Tests/HttpStartTests.cs)]
 
 ## 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 will validate the output of the `E1_HelloSequence` Orchestrator function:
+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)]
 
-The unit test code will start with creating a mock:
+The unit test code starts with creating a mock:
 
 ```csharp
 var durableOrchestrationContextMock = new Mock<IDurableOrchestrationContext>();
 ```
 
-Then the activity method calls will be mocked:
+Then the activity method calls are mocked:
 
 ```csharp
 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!");
 ```
 
-Next the unit test will call `HelloSequence.Run` method:
+Next, the unit test calls the `HelloSequence.Run` method:
 
 ```csharp
 var result = await HelloSequence.Run(durableOrchestrationContextMock.Object);
 ```
 
-And finally the output will be validated:
+And finally the output is validated:
 
 ```csharp
 Assert.Equal(3, result.Count);
@@ -158,19 +158,19 @@ Assert.Equal("Hello Seattle!", result[1]);
 Assert.Equal("Hello London!", result[2]);
 ```
 
-After combining all steps, the unit test will have the following code:
+After you combine the previous steps, the unit test has the following code:
 
 [!code-csharp[Main](~/samples-durable-functions/samples/VSSample.Tests/HelloSequenceOrchestratorTests.cs)]
 
 ## Unit testing activity functions
 
-Activity functions can be unit tested in the same way as non-durable functions.
+Activity functions are unit tested in the same way as nondurable functions.
 
-In this section the unit test will validate the behavior of the `E1_SayHello` Activity function:
+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)]
 
-And the unit tests will verify the format of the output. The unit tests can use the parameter types directly or mock `IDurableActivityContext` class:
+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)]