Updates.

Author: roygara

articles/api-management/workspaces-overview.md

@@ -132,6 +132,7 @@ The following constraints currently apply to workspace gateways:
 * Request metrics can't be split by workspace in Azure Monitor; all workspace metrics are aggregated at the service level
 * Workspace gateways don't support CA certificates
 * Workspace gateways don't support managed identities, including related features like storing secrets in Azure Key Vault and using the `authentication-managed-identity` policy
+* Workspace gateways can only be created in the API Management instance's primary Azure region 
 
 ## RBAC roles for workspaces
 

articles/app-service/app-service-configure-premium-v4-tier.md

@@ -3,7 +3,7 @@ title: Configure Premium V4 tier
 description: Learn how to better performance for your web, mobile, and API app in Azure App Service by scaling to the new Premium V4 pricing tier.
 keywords: app service, azure app service, scale, scalable, app service plan, app service cost
 ms.topic: article
-ms.date: 06/13/2025
+ms.date: 06/18/2025
 ms.author: msangapu
 author: msangapu-msft
 ms.custom:
@@ -98,14 +98,20 @@ Premium V4 is available in the following regions:
 
 - Australia East
 - Canada Central
+- Central US
 - East US
 - East US 2
 - France Central
+- North Central US
 - North Europe
+- Norway East
 - Southeast Asia
 - Sweden Central
+- Switzerland North
+- UK South
 - West Central US
 - West Europe
+- West US
 - West US 3
 
 ## Scale up from an unsupported resource group and region combination

articles/azure-app-configuration/howto-telemetry.md

@@ -6,7 +6,7 @@ ms.service: azure-app-configuration
 author: mrm9084
 ms.author: mametcal
 ms.topic: how-to
-ms.date: 03/05/2025
+ms.date: 06/19/2025
 ---
 
 # Enable telemetry for feature flags
@@ -33,7 +33,7 @@ These types of questions can be answered through the emission and analysis of fe
     > [!div class="mx-imgBorder"]
     > ![Screenshot of the Azure portal, connecting application insights.](./media/howto-telemetry/connect-to-app-insights.png)
 
-## Enable telemetry for a feature flag (preview)
+## Enable telemetry for a feature flag
 
 1. Open your App Configuration store in the Azure portal and select the **Feature manager** blade under the **Operations** section.
 1. Select the feature flag named Greeting. If you don't have it, follow the [instructions to create it](./manage-feature-flags.md). Then, right-click on the feature flag and select **Edit**.

articles/azure-compute-fleet/quickstart-create-azure-cli.md

@@ -80,7 +80,7 @@ export MY_SUBNET_ID="$(az network vnet subnet show \
 
 ## Set up the admin password
 
-Set up a password that meets the [password requirements for Azure VMs](https://learn.microsoft.com/azure/virtual-machines/windows/faq#what-are-the-password-requirements-when-creating-a-vm-).
+Set up a password that meets the [password requirements for Azure VMs](/azure/virtual-machines/windows/faq#what-are-the-password-requirements-when-creating-a-vm-).
 
 ```bash
 export ADMIN_PASSWORD="Azure compliant password"

articles/azure-functions/durable/TOC.yml

@@ -188,8 +188,10 @@
       href: durable-functions-create-portal.md
     - name: Manage connections
       href: ../manage-connections.md?toc=/azure/azure-functions/durable/toc.json
-    - name: Unit testing
+    - name: Unit testing (C#)
       href: durable-functions-unit-testing.md
+    - name: Unit testing (Python)
+      href: durable-functions-unit-testing-python.md
     - name: Create as WebJobs
       href: durable-functions-webjobs-sdk.md
     - name: Durable entities in .NET

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

@@ -0,0 +1,171 @@
+---
+title: Unit Testing Durable Functions in Python
+description: Learn about unit testing best practices for Durable functions written in Python for Azure Functions.
+author: andystaples
+ms.topic: conceptual
+ms.date: 05/07/2025
+ms.author: azfuncdf
+---
+
+# 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.
+
+> [!NOTE]
+> This guide applies only to Durable Functions apps written in the [Python v2 programming model](../functions-reference-python.md). 
+
+## Prerequisites
+
+The examples in this article require knowledge of the following concepts and frameworks:
+
+* Unit testing
+* Durable Functions
+* 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
+
+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).
+
+## Unit testing trigger functions
+
+Trigger functions, often referred to as _client_ functions, initiate orchestrations and external events. To test these functions:
+
+- Mock the `DurableOrchestrationClient` to simulate orchestration execution and status management.  
+- Assign `DurableOrchestrationClient` methods such as `start_new`, `get_status`, or `raise_event` with mock functions that return expected values.  
+- Invoke the client function directly with a mocked client and other necessary inputs such as a `req` (HTTP request object) for HTTP trigger client functions.  
+- Use assertions and `unittest.mock` tools to verify expected orchestration start behavior, parameters, and HTTP responses.
+
+```python
+import asyncio
+import unittest
+import azure.functions as func
+from unittest.mock import AsyncMock, Mock, patch
+
+from function_app import start_orchestrator
+
+class TestFunction(unittest.TestCase):
+  @patch('azure.durable_functions.DurableOrchestrationClient')
+  def test_HttpStart(self, client):
+    # Get the original method definition as seen in the function_app.py file
+    func_call = http_start.build().get_user_function().client_function
+
+    req = func.HttpRequest(method='GET',
+                           body=b'{}',
+                           url='/api/my_second_function',
+                           route_params={"functionName": "my_orchestrator"})
+
+    client.start_new = AsyncMock(return_value="instance_id")
+    client.create_check_status_response = Mock(return_value="check_status_response")
+
+    # Execute the function code
+    result = asyncio.run(func_call(req, client))
+
+    client.start_new.assert_called_once_with("my_orchestrator")
+    client.create_check_status_response.assert_called_once_with(req, "instance_id")
+    self.assertEqual(result, "check_status_response")
+```
+
+## Unit testing orchestrator functions
+
+Orchestrator functions manage the execution of multiple activity functions. To test an orchestrator:
+
+- Mock the `DurableOrchestrationContext` to control function execution.
+- Replace `DurableOrchestrationContext` methods needed for orchestrator execution like `call_activity` or `create_timer` with mock functions. These functions will typically return objects of type TaskBase with a `result` property.
+- Call the orchestrator recursively, passing the result of the Task generated by the previous yield statement to the next.
+- Verify the orchestrator result using the results returned from the orchestrator and `unittest.mock`.
+
+```python
+import unittest
+from unittest.mock import Mock, patch, call
+from datetime import timedelta
+from azure.durable_functions.testing import orchestrator_generator_wrapper
+
+from function_app import my_orchestrator
+
+
+class TestFunction(unittest.TestCase):
+  @patch('azure.durable_functions.DurableOrchestrationContext')
+  def test_chaining_orchestrator(self, context):
+    # Get the original method definition as seen in the function_app.py file
+    func_call = my_orchestrator.build().get_user_function().orchestrator_function
+
+    # The mock_activity method is defined above with behavior specific to your app.
+    # It returns a TaskBase object with the result expected from the activity call.
+    context.call_activity = Mock(side_effect=mock_activity)
+
+    # Create a generator using the method and mocked context
+    user_orchestrator = func_call(context)
+
+    # Use orchestrator_generator_wrapper to get the values from the generator.
+    # Processes the orchestrator in a way that is equivalent to the Durable replay logic
+    values = [val for val in orchestrator_generator_wrapper(user_orchestrator)]
+
+    expected_activity_calls = [call('say_hello', 'Tokyo'),
+                               call('say_hello', 'Seattle'),
+                               call('say_hello', 'London')]
+    
+    self.assertEqual(context.call_activity.call_count, 3)
+    self.assertEqual(context.call_activity.call_args_list, expected_activity_calls)
+    self.assertEqual(values[3], ["Hello Tokyo!", "Hello Seattle!", "Hello London!"])
+```
+
+## Unit testing entity functions
+
+Entity functions manage stateful objects with operations. To test an entity function:
+
+- Mock the `DurableEntityContext` to simulate the entity's internal state and operation inputs.  
+- Replace `DurableEntityContext` methods like `get_state`, `set_state`, and `operation_name` with mocks that return controlled values.  
+- Invoke the entity function directly with the mocked context.  
+- Use assertions to verify state changes and returned values, along with `unittest.mock` utilities.
+
+```python
+import unittest
+from unittest.mock import Mock, patch
+
+from function_app import Counter
+
+class TestEntityFunction(unittest.TestCase):
+  @patch('azure.durable_functions.DurableEntityContext')
+  def test_entity_add_operation(self, context_mock):
+    # Get the original method definition as seen in function_app.py
+    func_call = Counter.build().get_user_function().entity_function
+    
+    # Setup mock context behavior
+    state = 0
+    result = None
+
+    def set_state(new_state):
+        nonlocal state
+        state = new_state
+
+    def set_result(new_result):
+        nonlocal result
+        result = new_result
+
+    context_mock.get_state = Mock(return_value=state)
+    context_mock.set_state = Mock(side_effect=set_state)
+
+    context_mock.operation_name = "add"
+    context_mock.get_input = Mock(return_value=5)
+
+    context_mock.set_result = Mock(side_effect=lambda x: set_result)
+
+    # Call the entity function with the mocked context
+    func_call(context_mock)
+
+    # Verify the state was updated correctly
+    context_mock.set_state.assert_called_once_with(5)
+    self.assertEqual(state, 5)
+    self.assertEqual(result, None)
+```
+
+## Unit testing activity functions
+
+Activity functions require no Durable-specific modifications to be tested. The guidance found in the [Azure Functions Python unit testing overview](../functions-reference-python.md#unit-testing) is sufficient for testing these functions. 
+
+## Related content
+
+- [Learn how to improve throughput performance of Python apps in Azure Functions](../python-scale-performance-reference.md)
+- [Read the Azure Functions Python Developer Guide](../functions-reference-python.md)
+- [Learn about Durable Functions best practices and diagnostic tools](./durable-functions-best-practice-reference.md)

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

@@ -7,7 +7,7 @@ ms.date: 11/03/2019
 
 # Durable Functions unit testing (C#)
 
-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 will help to avoid breaking changes. The following sections explain how to unit test the three function types - Orchestration client, orchestrator, and activity functions.
+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 activity functions.
 
 > [!NOTE]
 > This article provides guidance for unit testing for Durable Functions apps written in C# for the .NET in-process worker and targeting Durable Functions 2.x. For more information about the differences between versions, see the [Durable Functions versions](durable-functions-versions.md) article.
@@ -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)]
 

articles/azure-functions/durable/quickstart-python-vscode.md

@@ -242,3 +242,4 @@ If you no longer need the resources that you created to complete the quickstart,
 ## Related content
 
 * Learn about [common Durable Functions app patterns](durable-functions-overview.md#application-patterns).
+* Learn about [Unit Testing Durable Functions in Python](durable-functions-unit-testing-python.md)

articles/azure-functions/functions-reference-python.md

@@ -1344,6 +1344,9 @@ class TestFunction(unittest.TestCase):
 
 Inside your *.venv* Python virtual environment folder, install your favorite Python test framework, such as `pip install pytest`. Then run `pytest tests` to check the test result.
 
+> [!NOTE]
+> Durable Functions require special syntax for unit testing. For more information, refer to [Unit Testing Durable Functions in Python](durable/durable-functions-unit-testing-python.md)
+
 ::: zone-end
 
 ## Temporary files