test(durable): cover native-runtime gRPC protocol selection + clarify comment

Address review feedback on the native-runtime recognition change:

- Update the protocol-selection comment to reflect that native (Go) and custom-handler runtimes also use the gRPC MiddlewarePassthrough protocol, not just .NET isolated and Java.

- Add unit tests asserting Native/Golang select MiddlewarePassthrough (not the legacy HTTP shim).

- Add unit tests asserting Native/Golang default UseSeparateQueueForEntityWorkItems=true, with an in-proc .NET counter-test.

Author: ahmedmuhsin

src/WebJobs.Extensions.DurableTask/DurableTaskExtension.cs

@@ -166,8 +166,11 @@ public DurableTaskExtension(
             this.telemetryActivator = telemetryActivator;
             this.telemetryActivator?.Initialize(logger);
 
-            // Starting with .NET isolated and Java, we have a more efficient out-of-process
-            // function invocation protocol. Other languages will use the existing protocol.
+            // The gRPC-based out-of-process invocation protocol (MiddlewarePassthrough) is the more
+            // efficient protocol used by the compiled / newer-SDK runtimes: .NET isolated, Java, the
+            // native worker (e.g. Go), and custom handlers. The remaining script languages (Python,
+            // Node.js, PowerShell) start on the legacy HTTP protocol below and may upgrade to gRPC
+            // during function indexing if their metadata requests it (see ConfigureForGrpcProtocol).
             WorkerRuntimeType runtimeType = this.PlatformInformationService.GetWorkerRuntimeType();
             if (runtimeType == WorkerRuntimeType.DotNetIsolated ||
                 runtimeType == WorkerRuntimeType.Java ||

test/FunctionsV2/Tests/Unit/AzureStorageDurabilityProviderFactoryTests.cs

@@ -78,6 +78,50 @@ public void ConsumptionDefaultsForPythonAreApplied()
             Assert.Equal(25, settings.MaxStorageOperationConcurrency);
         }
 
+        [Theory]
+        [Trait("Category", PlatformSpecificHelpers.TestCategory)]
+        [InlineData(WorkerRuntimeType.Native)]
+        [InlineData(WorkerRuntimeType.Golang)]
+        public void GrpcRuntimes_UseSeparateQueueForEntityWorkItems(WorkerRuntimeType runtimeType)
+        {
+            var clientProviderFactory = new TestStorageServiceClientProviderFactory();
+            var mockOptions = new OptionsWrapper<DurableTaskOptions>(new DurableTaskOptions());
+            var nameResolver = new Mock<INameResolver>().Object;
+            var factory = new AzureStorageDurabilityProviderFactory(
+                mockOptions,
+                clientProviderFactory,
+                nameResolver,
+                NullLoggerFactory.Instance,
+                TestHelpers.GetMockPlatformInformationService(language: runtimeType));
+
+            var settings = factory.GetAzureStorageOrchestrationServiceSettings();
+
+            // The native worker runtimes use the gRPC protocol, which requires a separate
+            // queue for entity work items (matching .NET isolated / Java behavior).
+            Assert.True(settings.UseSeparateQueueForEntityWorkItems);
+        }
+
+        [Fact]
+        [Trait("Category", PlatformSpecificHelpers.TestCategory)]
+        public void InProcRuntime_DoesNotUseSeparateQueueForEntityWorkItems()
+        {
+            var clientProviderFactory = new TestStorageServiceClientProviderFactory();
+            var mockOptions = new OptionsWrapper<DurableTaskOptions>(new DurableTaskOptions());
+            var nameResolver = new Mock<INameResolver>().Object;
+            var factory = new AzureStorageDurabilityProviderFactory(
+                mockOptions,
+                clientProviderFactory,
+                nameResolver,
+                NullLoggerFactory.Instance,
+                TestHelpers.GetMockPlatformInformationService(language: WorkerRuntimeType.DotNet));
+
+            var settings = factory.GetAzureStorageOrchestrationServiceSettings();
+
+            // The in-process .NET runtime keeps the shared queue (this default is flipped
+            // to true only for the gRPC-based runtimes).
+            Assert.False(settings.UseSeparateQueueForEntityWorkItems);
+        }
+
         [Fact]
         [Trait("Category", PlatformSpecificHelpers.TestCategory)]
         public void ConsumptionDefaultsAreNotAlwaysApplied()

test/FunctionsV2/Tests/Unit/LocalGrpcListenerTests.cs

@@ -502,7 +502,31 @@ public void TestBindingHelper_ThrowsGrpcChannelUnavailableException_WhenGrpcAddr
             Assert.Contains("transient", ex.Message);
         }
 
+        /// <summary>
+        /// Verifies that the native worker runtimes (the Go worker reports either "native" or,
+        /// defensively, "golang") select the gRPC protocol (MiddlewarePassthrough) at extension
+        /// initialization rather than the legacy HTTP-correlation shim (OrchestratorShim). When
+        /// MiddlewarePassthrough is selected the local HTTP RPC server is never started — the
+        /// runtime communicates durable operations over the local gRPC sidecar instead.
+        /// </summary>
+        [Theory]
+        [Trait("Category", PlatformSpecificHelpers.TestCategory)]
+        [InlineData(WorkerRuntimeType.Native)]
+        [InlineData(WorkerRuntimeType.Golang)]
+        public void TestNativeRuntime_SelectsGrpcProtocol(WorkerRuntimeType runtimeType)
+        {
+            using DurableTaskExtension extension = this.CreateExtension("NativeRuntimeProtocol", runtimeType);
+
+            Assert.Equal(OutOfProcOrchestrationProtocol.MiddlewarePassthrough, extension.OutOfProcProtocol);
+            Assert.NotEqual(OutOfProcOrchestrationProtocol.OrchestratorShim, extension.OutOfProcProtocol);
+        }
+
         private DurableTaskExtension CreateExtension(string hubName)
+        {
+            return this.CreateExtension(hubName, WorkerRuntimeType.DotNetIsolated);
+        }
+
+        private DurableTaskExtension CreateExtension(string hubName, WorkerRuntimeType runtimeType)
         {
             var options = new DurableTaskOptions { HubName = hubName };
             var wrappedOptions = new OptionsWrapper<DurableTaskOptions>(options);
@@ -512,7 +536,7 @@ private DurableTaskExtension CreateExtension(string hubName)
                 new TestStorageServiceClientProviderFactory(),
                 nameResolver,
                 NullLoggerFactory.Instance,
-                TestHelpers.GetMockPlatformInformationService(language: WorkerRuntimeType.DotNetIsolated));
+                TestHelpers.GetMockPlatformInformationService(language: runtimeType));
 
             return new DurableTaskExtension(
                 wrappedOptions,
@@ -521,7 +545,7 @@ private DurableTaskExtension CreateExtension(string hubName)
                 new[] { serviceFactory },
                 new TestHostShutdownNotificationService(),
                 new DurableHttpMessageHandlerFactory(),
-                platformInformationService: TestHelpers.GetMockPlatformInformationService(language: WorkerRuntimeType.DotNetIsolated));
+                platformInformationService: TestHelpers.GetMockPlatformInformationService(language: runtimeType));
         }
 
         /// <summary>