From 4296ae9f58d803e6fa7ac1db50975876451bc37b Mon Sep 17 00:00:00 2001 From: YunchuWang <12449837+YunchuWang@users.noreply.github.com> Date: Wed, 5 Aug 2026 17:46:48 -0700 Subject: [PATCH 01/13] Reject starts for disabled orchestrators Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> Copilot-Session: 47efed8f-40ca-43b8-8564-de5406bafbc0 --- .../DurableTaskExtension.cs | 2 +- .../Unit/DisabledFunctionDispatchTests.cs | 13 ++++++++ .../Tests/Unit/DurableClientBaseTests.cs | 30 +++++++++++++++++++ 3 files changed, 44 insertions(+), 1 deletion(-) diff --git a/src/WebJobs.Extensions.DurableTask/DurableTaskExtension.cs b/src/WebJobs.Extensions.DurableTask/DurableTaskExtension.cs index 4a4e6f671..7bd900516 100644 --- a/src/WebJobs.Extensions.DurableTask/DurableTaskExtension.cs +++ b/src/WebJobs.Extensions.DurableTask/DurableTaskExtension.cs @@ -1485,7 +1485,7 @@ internal void ThrowIfFunctionDoesNotExist(string name, FunctionType functionType { throw new ArgumentException(this.GetInvalidActivityFunctionMessage(name)); } - else if (functionType == FunctionType.Orchestrator && !this.knownOrchestrators.ContainsKey(functionName)) + else if (functionType == FunctionType.Orchestrator && this.GetOrchestratorInfo(functionName) == null) { throw new ArgumentException(this.GetInvalidOrchestratorFunctionMessage(name)); } diff --git a/test/FunctionsV2/Tests/Unit/DisabledFunctionDispatchTests.cs b/test/FunctionsV2/Tests/Unit/DisabledFunctionDispatchTests.cs index 2fe6bedd5..286492406 100644 --- a/test/FunctionsV2/Tests/Unit/DisabledFunctionDispatchTests.cs +++ b/test/FunctionsV2/Tests/Unit/DisabledFunctionDispatchTests.cs @@ -91,6 +91,19 @@ public void GetObject_ActiveActivity_ReturnsRealActivityShim() Assert.IsType(shim); } + [Fact] + [Trait("Category", PlatformSpecificHelpers.TestCategory)] + public void ThrowIfFunctionDoesNotExist_ActiveOutOfProcOrchestrator_DoesNotThrow() + { + var extension = CreateExtension(); + var mockExecutor = new Mock(); + extension.RegisterOrchestrator( + new FunctionName("ActiveOrchestrator"), + new RegisteredFunctionInfo(mockExecutor.Object, isOutOfProc: true)); + + extension.ThrowIfFunctionDoesNotExist("ActiveOrchestrator", FunctionType.Orchestrator); + } + [Fact] [Trait("Category", PlatformSpecificHelpers.TestCategory)] public void DisabledEntity_IsTreatedAsUnavailableByClassicDispatch() diff --git a/test/FunctionsV2/Tests/Unit/DurableClientBaseTests.cs b/test/FunctionsV2/Tests/Unit/DurableClientBaseTests.cs index 3dd7488ad..0cf269016 100644 --- a/test/FunctionsV2/Tests/Unit/DurableClientBaseTests.cs +++ b/test/FunctionsV2/Tests/Unit/DurableClientBaseTests.cs @@ -51,6 +51,36 @@ public async Task StartNewAsync_InvalidInstanceId_ThrowsException(string instanc await Assert.ThrowsAnyAsync(async () => await durableClient.StartNewAsync("anyOrchestratorFunction", instanceId, new { message = "any obj" })); } + [Fact] + [Trait("Category", PlatformSpecificHelpers.TestCategory)] + public async Task StartNewAsync_DisabledOrchestrator_ThrowsException() + { + var orchestrationServiceClientMock = new Mock(); + orchestrationServiceClientMock + .Setup(x => x.CreateTaskOrchestrationAsync(It.IsAny(), It.IsAny())) + .Returns(Task.CompletedTask); + var storageProvider = new DurabilityProvider( + "test", + new Mock().Object, + orchestrationServiceClientMock.Object, + "test"); + var durableExtension = GetDurableTaskConfig(); + durableExtension.RegisterOrchestrator(new FunctionName("DisabledOrchestrator"), orchestratorInfo: null); + var durableClient = (IDurableOrchestrationClient)new DurableClient( + storageProvider, + durableExtension, + durableExtension.HttpApiHandler, + new DurableClientAttribute { }); + + ArgumentException exception = await Assert.ThrowsAsync( + () => durableClient.StartNewAsync("DisabledOrchestrator")); + + Assert.Contains("doesn't exist, is disabled, or is not an orchestrator function", exception.Message); + orchestrationServiceClientMock.Verify( + x => x.CreateTaskOrchestrationAsync(It.IsAny(), It.IsAny()), + Times.Never()); + } + [Theory] [Trait("Category", PlatformSpecificHelpers.TestCategory)] [InlineData("@invalid")] From dc40adbb32c9ed5559972e4b3dfc155215e24068 Mon Sep 17 00:00:00 2001 From: YunchuWang <12449837+YunchuWang@users.noreply.github.com> Date: Wed, 5 Aug 2026 18:10:52 -0700 Subject: [PATCH 02/13] Validate disabled orchestrators at start boundaries Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> Copilot-Session: 47efed8f-40ca-43b8-8564-de5406bafbc0 --- .../ContextImplementations/DurableClient.cs | 9 +- .../DurableTaskExtension.cs | 10 ++- .../HttpApiHandler.cs | 5 ++ .../TaskHubGrpcServer.cs | 2 + .../Unit/DisabledFunctionDispatchTests.cs | 17 +++- .../Tests/Unit/HttpApiHandlerTests.cs | 84 +++++++++++++++++++ .../Tests/Unit/LocalGrpcListenerTests.cs | 43 +++++++++- 7 files changed, 163 insertions(+), 7 deletions(-) diff --git a/src/WebJobs.Extensions.DurableTask/ContextImplementations/DurableClient.cs b/src/WebJobs.Extensions.DurableTask/ContextImplementations/DurableClient.cs index 67d85c640..13d050c8f 100644 --- a/src/WebJobs.Extensions.DurableTask/ContextImplementations/DurableClient.cs +++ b/src/WebJobs.Extensions.DurableTask/ContextImplementations/DurableClient.cs @@ -176,9 +176,9 @@ async Task IDurableOrchestrationClient.WaitForCompletionOrCreateC /// async Task IDurableOrchestrationClient.StartNewAsync(string orchestratorFunctionName, string instanceId, T input) { - if (this.ClientReferencesCurrentApp(this)) + if (this.ReferencesCurrentApp()) { - this.config?.ThrowIfFunctionDoesNotExist(orchestratorFunctionName, FunctionType.Orchestrator); + this.config?.ThrowIfOrchestratorFunctionIsUnavailable(orchestratorFunctionName); } if (string.IsNullOrEmpty(instanceId)) @@ -361,6 +361,11 @@ private bool ClientReferencesCurrentApp(DurableClient client) this.ConnectionNameMatchesCurrentApp(client); } + internal bool ReferencesCurrentApp() + { + return this.ClientReferencesCurrentApp(this); + } + private bool TaskHubMatchesCurrentApp(DurableClient client) { var taskHubName = this.durableTaskOptions.HubName; diff --git a/src/WebJobs.Extensions.DurableTask/DurableTaskExtension.cs b/src/WebJobs.Extensions.DurableTask/DurableTaskExtension.cs index 7bd900516..55c9b43e9 100644 --- a/src/WebJobs.Extensions.DurableTask/DurableTaskExtension.cs +++ b/src/WebJobs.Extensions.DurableTask/DurableTaskExtension.cs @@ -1485,7 +1485,7 @@ internal void ThrowIfFunctionDoesNotExist(string name, FunctionType functionType { throw new ArgumentException(this.GetInvalidActivityFunctionMessage(name)); } - else if (functionType == FunctionType.Orchestrator && this.GetOrchestratorInfo(functionName) == null) + else if (functionType == FunctionType.Orchestrator && !this.knownOrchestrators.ContainsKey(functionName)) { throw new ArgumentException(this.GetInvalidOrchestratorFunctionMessage(name)); } @@ -1495,6 +1495,14 @@ internal void ThrowIfFunctionDoesNotExist(string name, FunctionType functionType } } + internal void ThrowIfOrchestratorFunctionIsUnavailable(string name) + { + if (this.GetOrchestratorInfo(new FunctionName(name)) == null) + { + throw new ArgumentException(this.GetInvalidOrchestratorFunctionMessage(name)); + } + } + private static bool IsDurableHttpTask(string functionName) { return string.Equals(functionName, HttpOptions.HttpTaskActivityReservedName); diff --git a/src/WebJobs.Extensions.DurableTask/HttpApiHandler.cs b/src/WebJobs.Extensions.DurableTask/HttpApiHandler.cs index 4429f8d1c..14a642853 100644 --- a/src/WebJobs.Extensions.DurableTask/HttpApiHandler.cs +++ b/src/WebJobs.Extensions.DurableTask/HttpApiHandler.cs @@ -957,6 +957,11 @@ private async Task HandleStartOrchestratorRequestAsync( if (client is DurableClient durableClient) { + if (durableClient.ReferencesCurrentApp()) + { + this.config.ThrowIfOrchestratorFunctionIsUnavailable(functionName); + } + var instance = new OrchestrationInstance { InstanceId = id, diff --git a/src/WebJobs.Extensions.DurableTask/TaskHubGrpcServer.cs b/src/WebJobs.Extensions.DurableTask/TaskHubGrpcServer.cs index bedfba7a3..919052c4e 100644 --- a/src/WebJobs.Extensions.DurableTask/TaskHubGrpcServer.cs +++ b/src/WebJobs.Extensions.DurableTask/TaskHubGrpcServer.cs @@ -59,6 +59,8 @@ public override Task Hello(Empty request, ServerCallContext context) { try { + this.extension.ThrowIfOrchestratorFunctionIsUnavailable(request.Name); + List allStatuses = System.Enum .GetValues() .ToList(); diff --git a/test/FunctionsV2/Tests/Unit/DisabledFunctionDispatchTests.cs b/test/FunctionsV2/Tests/Unit/DisabledFunctionDispatchTests.cs index 286492406..4ff69dd8f 100644 --- a/test/FunctionsV2/Tests/Unit/DisabledFunctionDispatchTests.cs +++ b/test/FunctionsV2/Tests/Unit/DisabledFunctionDispatchTests.cs @@ -93,7 +93,7 @@ public void GetObject_ActiveActivity_ReturnsRealActivityShim() [Fact] [Trait("Category", PlatformSpecificHelpers.TestCategory)] - public void ThrowIfFunctionDoesNotExist_ActiveOutOfProcOrchestrator_DoesNotThrow() + public void ThrowIfOrchestratorFunctionIsUnavailable_ActiveOutOfProcOrchestrator_DoesNotThrow() { var extension = CreateExtension(); var mockExecutor = new Mock(); @@ -101,7 +101,20 @@ public void ThrowIfFunctionDoesNotExist_ActiveOutOfProcOrchestrator_DoesNotThrow new FunctionName("ActiveOrchestrator"), new RegisteredFunctionInfo(mockExecutor.Object, isOutOfProc: true)); - extension.ThrowIfFunctionDoesNotExist("ActiveOrchestrator", FunctionType.Orchestrator); + extension.ThrowIfOrchestratorFunctionIsUnavailable("ActiveOrchestrator"); + } + + [Fact] + [Trait("Category", PlatformSpecificHelpers.TestCategory)] + public void ThrowIfFunctionDoesNotExist_DisabledOrchestrator_DoesNotBreakReplay() + { + // Deterministic orchestration calls use this helper while replaying history. A disabled + // orchestrator remains a known function, so availability checks belong only at new-start + // entry points and must not make existing sub-orchestration history fail to replay. + var extension = CreateExtension(); + extension.RegisterOrchestrator(new FunctionName("DisabledOrchestrator"), orchestratorInfo: null); + + extension.ThrowIfFunctionDoesNotExist("DisabledOrchestrator", FunctionType.Orchestrator); } [Fact] diff --git a/test/FunctionsV2/Tests/Unit/HttpApiHandlerTests.cs b/test/FunctionsV2/Tests/Unit/HttpApiHandlerTests.cs index 29b0169bc..e23338dbf 100644 --- a/test/FunctionsV2/Tests/Unit/HttpApiHandlerTests.cs +++ b/test/FunctionsV2/Tests/Unit/HttpApiHandlerTests.cs @@ -1958,6 +1958,9 @@ public async Task StartNewInstance_Calls_CreateTaskOrchestrationAsync_With_Corre }; var customExtension = TestDurableTaskExtension.CreateWithProvider(options, durabilityProvider); + customExtension.RegisterOrchestrator( + new FunctionName(functionName), + new RegisteredFunctionInfo(executor: null, isOutOfProc: true)); var handler = new HttpApiHandler(customExtension, NullLogger.Instance); var request = new HttpRequestMessage(HttpMethod.Post, requestUri); @@ -1973,6 +1976,87 @@ public async Task StartNewInstance_Calls_CreateTaskOrchestrationAsync_With_Corre Assert.Equal(expectedVersion, capturedEvent.Version); } + [Fact] + [Trait("Category", PlatformSpecificHelpers.TestCategory)] + public async Task StartNewInstance_Returns_HTTP_400_On_Disabled_Function() + { + const string FunctionName = "DisabledOrchestrator"; + var requestUri = new Uri( + $"http://localhost/runtime/webhooks/durabletask/orchestrators/{FunctionName}"); + var orchestrationServiceMock = new Mock(MockBehavior.Strict); + var orchestrationServiceClientMock = new Mock(); + orchestrationServiceClientMock + .Setup(p => p.CreateTaskOrchestrationAsync( + It.IsAny(), + It.IsAny())) + .Returns(Task.CompletedTask); + var durabilityProvider = new DurabilityProvider( + "storageProviderName", + orchestrationServiceMock.Object, + orchestrationServiceClientMock.Object, + "connectionName"); + var options = new DurableTaskOptions + { + WebhookUriProviderOverride = () => new Uri("http://localhost/runtime/webhooks/durabletask"), + HubName = TestConstants.TaskHub, + }; + var extension = TestDurableTaskExtension.CreateWithProvider(options, durabilityProvider); + extension.RegisterOrchestrator(new FunctionName(FunctionName), orchestratorInfo: null); + var handler = new HttpApiHandler(extension, NullLogger.Instance); + + HttpResponseMessage response = await handler.HandleRequestAsync( + new HttpRequestMessage(HttpMethod.Post, requestUri), + CancellationToken.None); + + Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); + string content = await response.Content.ReadAsStringAsync(); + Assert.Contains("doesn't exist, is disabled, or is not an orchestrator function", content); + orchestrationServiceClientMock.Verify( + p => p.CreateTaskOrchestrationAsync( + It.IsAny(), + It.IsAny()), + Times.Never); + } + + [Fact] + [Trait("Category", PlatformSpecificHelpers.TestCategory)] + public async Task StartNewInstance_ExternalTaskHub_DoesNotValidateLocalFunction() + { + const string FunctionName = "RemoteOrchestrator"; + var requestUri = new Uri( + $"http://localhost/runtime/webhooks/durabletask/orchestrators/{FunctionName}?taskHub=RemoteHub"); + var orchestrationServiceMock = new Mock(MockBehavior.Strict); + var orchestrationServiceClientMock = new Mock(); + orchestrationServiceClientMock + .Setup(p => p.CreateTaskOrchestrationAsync( + It.IsAny(), + It.IsAny())) + .Returns(Task.CompletedTask); + var durabilityProvider = new DurabilityProvider( + "storageProviderName", + orchestrationServiceMock.Object, + orchestrationServiceClientMock.Object, + "connectionName"); + var options = new DurableTaskOptions + { + WebhookUriProviderOverride = () => new Uri("http://localhost/runtime/webhooks/durabletask"), + HubName = TestConstants.TaskHub, + }; + var extension = TestDurableTaskExtension.CreateWithProvider(options, durabilityProvider); + var handler = new HttpApiHandler(extension, NullLogger.Instance); + + HttpResponseMessage response = await handler.HandleRequestAsync( + new HttpRequestMessage(HttpMethod.Post, requestUri), + CancellationToken.None); + + Assert.Equal(HttpStatusCode.Accepted, response.StatusCode); + orchestrationServiceClientMock.Verify( + p => p.CreateTaskOrchestrationAsync( + It.IsAny(), + It.IsAny()), + Times.Once); + } + private static DurableTaskExtension GetTestExtension() { var options = new DurableTaskOptions(); diff --git a/test/FunctionsV2/Tests/Unit/LocalGrpcListenerTests.cs b/test/FunctionsV2/Tests/Unit/LocalGrpcListenerTests.cs index 926404d68..6701365d2 100644 --- a/test/FunctionsV2/Tests/Unit/LocalGrpcListenerTests.cs +++ b/test/FunctionsV2/Tests/Unit/LocalGrpcListenerTests.cs @@ -212,7 +212,10 @@ public async Task TestGrpcListener_DoesNotLogStartInstanceClientCancellation() await providerCalled.Task.WaitAsync(TimeSpan.FromSeconds(5)); cancellation.Cancel(); await call.ResponseAsync; - }); + }, + extension => extension.RegisterOrchestrator( + new FunctionName("TestOrchestration"), + new RegisteredFunctionInfo(executor: null, isOutOfProc: true))); Assert.Equal(StatusCode.Cancelled, rpcException.StatusCode); Assert.DoesNotContain( @@ -221,6 +224,40 @@ public async Task TestGrpcListener_DoesNotLogStartInstanceClientCancellation() message.FormattedMessage.Contains("StartInstance")); } + [Fact] + [Trait("Category", PlatformSpecificHelpers.TestCategory)] + public async Task TestGrpcListener_RejectsDisabledOrchestrator() + { + const string FunctionName = "DisabledOrchestrator"; + Mock durabilityProvider = CreateDurabilityProviderMock( + new Mock().Object, + new Mock().Object); + durabilityProvider + .Setup(provider => provider.CreateTaskOrchestrationAsync( + It.IsAny(), + It.IsAny(), + It.IsAny())) + .Returns(Task.CompletedTask); + + RpcException rpcException = await this.InvokeFailingRpcAsync( + "DisabledOrchestratorStart", + durabilityProvider.Object, + async client => await client.StartInstanceAsync( + new P.CreateInstanceRequest { Name = FunctionName }).ResponseAsync, + extension => extension.RegisterOrchestrator( + new FunctionName(FunctionName), + orchestratorInfo: null)); + + Assert.Equal(StatusCode.InvalidArgument, rpcException.StatusCode); + Assert.Contains("doesn't exist, is disabled, or is not an orchestrator function", rpcException.Status.Detail); + durabilityProvider.Verify( + provider => provider.CreateTaskOrchestrationAsync( + It.IsAny(), + It.IsAny(), + It.IsAny()), + Times.Never); + } + [Theory] [InlineData(false, nameof(ApplicationException))] [InlineData(true, nameof(OperationCanceledException))] @@ -923,9 +960,11 @@ private DurableTaskExtension CreateExtension(string hubName) private async Task InvokeFailingRpcAsync( string hubName, DurabilityProvider durabilityProvider, - Func invoke) + Func invoke, + Action configureExtension = null) { using DurableTaskExtension extension = this.CreateExtension(hubName, durabilityProvider); + configureExtension?.Invoke(extension); ILocalGrpcListener listener = LocalGrpcListener.Create(extension, LocalGrpcListenerMode.AspNetCore); try From b1e39c04de5036a7e25fda35b763218f6ae21166 Mon Sep 17 00:00:00 2001 From: YunchuWang <12449837+YunchuWang@users.noreply.github.com> Date: Wed, 5 Aug 2026 18:35:03 -0700 Subject: [PATCH 03/13] Cover restart and external client targets Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> Copilot-Session: 47efed8f-40ca-43b8-8564-de5406bafbc0 --- .../ContextImplementations/DurableClient.cs | 8 +- .../DurableTaskExtension.cs | 2 +- ...rchestratorFunctionUnavailableException.cs | 15 +++ .../HttpApiHandler.cs | 4 + .../TaskHubGrpcServer.cs | 9 +- .../Tests/Unit/DurableClientBaseTests.cs | 55 +++++++- .../Tests/Unit/HttpApiHandlerTests.cs | 46 ++++++- .../Tests/Unit/LocalGrpcListenerTests.cs | 119 +++++++++++++++++- 8 files changed, 242 insertions(+), 16 deletions(-) create mode 100644 src/WebJobs.Extensions.DurableTask/Exceptions/OrchestratorFunctionUnavailableException.cs diff --git a/src/WebJobs.Extensions.DurableTask/ContextImplementations/DurableClient.cs b/src/WebJobs.Extensions.DurableTask/ContextImplementations/DurableClient.cs index 13d050c8f..ce4861f48 100644 --- a/src/WebJobs.Extensions.DurableTask/ContextImplementations/DurableClient.cs +++ b/src/WebJobs.Extensions.DurableTask/ContextImplementations/DurableClient.cs @@ -374,7 +374,8 @@ private bool TaskHubMatchesCurrentApp(DurableClient client) private bool ConnectionNameMatchesCurrentApp(DurableClient client) { - return this.DurabilityProvider.ConnectionNameMatches(client.DurabilityProvider); + return this.config != null && + this.config.DefaultDurabilityProvider.ConnectionNameMatches(client.DurabilityProvider); } /// @@ -1262,6 +1263,11 @@ async Task IDurableOrchestrationClient.RestartAsync(string instanceId, b // GetOrchestrationInstanceStateAsync will throw ArgumentException if the provided instanceid is not found. OrchestrationState state = await this.GetOrchestrationInstanceStateAsync(instanceId); + if (this.ReferencesCurrentApp()) + { + this.config?.ThrowIfOrchestratorFunctionIsUnavailable(state.Name); + } + JToken input = ParseToJToken(state.Input); string newInstanceId = null; diff --git a/src/WebJobs.Extensions.DurableTask/DurableTaskExtension.cs b/src/WebJobs.Extensions.DurableTask/DurableTaskExtension.cs index 55c9b43e9..9bd495121 100644 --- a/src/WebJobs.Extensions.DurableTask/DurableTaskExtension.cs +++ b/src/WebJobs.Extensions.DurableTask/DurableTaskExtension.cs @@ -1499,7 +1499,7 @@ internal void ThrowIfOrchestratorFunctionIsUnavailable(string name) { if (this.GetOrchestratorInfo(new FunctionName(name)) == null) { - throw new ArgumentException(this.GetInvalidOrchestratorFunctionMessage(name)); + throw new OrchestratorFunctionUnavailableException(this.GetInvalidOrchestratorFunctionMessage(name)); } } diff --git a/src/WebJobs.Extensions.DurableTask/Exceptions/OrchestratorFunctionUnavailableException.cs b/src/WebJobs.Extensions.DurableTask/Exceptions/OrchestratorFunctionUnavailableException.cs new file mode 100644 index 000000000..81fd4fd4c --- /dev/null +++ b/src/WebJobs.Extensions.DurableTask/Exceptions/OrchestratorFunctionUnavailableException.cs @@ -0,0 +1,15 @@ +// Copyright (c) .NET Foundation. All rights reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +using System; + +namespace Microsoft.Azure.WebJobs.Extensions.DurableTask +{ + internal sealed class OrchestratorFunctionUnavailableException : ArgumentException + { + internal OrchestratorFunctionUnavailableException(string message) + : base(message) + { + } + } +} diff --git a/src/WebJobs.Extensions.DurableTask/HttpApiHandler.cs b/src/WebJobs.Extensions.DurableTask/HttpApiHandler.cs index 14a642853..4649d3c88 100644 --- a/src/WebJobs.Extensions.DurableTask/HttpApiHandler.cs +++ b/src/WebJobs.Extensions.DurableTask/HttpApiHandler.cs @@ -1105,6 +1105,10 @@ private async Task HandleRestartInstanceRequestAsync( return client.CreateCheckStatusResponse(request, newInstanceId); } } + catch (OrchestratorFunctionUnavailableException e) + { + return request.CreateErrorResponse(HttpStatusCode.BadRequest, e.Message, e); + } catch (ArgumentException e) { return request.CreateErrorResponse(HttpStatusCode.BadRequest, "InstanceId does not match a valid orchestration instance.", e); diff --git a/src/WebJobs.Extensions.DurableTask/TaskHubGrpcServer.cs b/src/WebJobs.Extensions.DurableTask/TaskHubGrpcServer.cs index 919052c4e..5261952df 100644 --- a/src/WebJobs.Extensions.DurableTask/TaskHubGrpcServer.cs +++ b/src/WebJobs.Extensions.DurableTask/TaskHubGrpcServer.cs @@ -59,7 +59,10 @@ public override Task Hello(Empty request, ServerCallContext context) { try { - this.extension.ThrowIfOrchestratorFunctionIsUnavailable(request.Name); + if (this.GetClient(context) is DurableClient durableClient && durableClient.ReferencesCurrentApp()) + { + this.extension.ThrowIfOrchestratorFunctionIsUnavailable(request.Name); + } List allStatuses = System.Enum .GetValues() @@ -523,6 +526,10 @@ await this.GetDurabilityProvider(context).CreateTaskOrchestrationAsync( string newInstanceId = await this.GetClient(context).RestartAsync(request.InstanceId, request.RestartWithNewInstanceId); return new P.RestartInstanceResponse { InstanceId = newInstanceId }; } + catch (OrchestratorFunctionUnavailableException ex) + { + throw new RpcException(new Status(StatusCode.InvalidArgument, ex.Message)); + } catch (ArgumentException ex) { // Thrown when th instanceId is not found. diff --git a/test/FunctionsV2/Tests/Unit/DurableClientBaseTests.cs b/test/FunctionsV2/Tests/Unit/DurableClientBaseTests.cs index 0cf269016..15e7fb698 100644 --- a/test/FunctionsV2/Tests/Unit/DurableClientBaseTests.cs +++ b/test/FunctionsV2/Tests/Unit/DurableClientBaseTests.cs @@ -63,7 +63,7 @@ public async Task StartNewAsync_DisabledOrchestrator_ThrowsException() "test", new Mock().Object, orchestrationServiceClientMock.Object, - "test"); + TestConstants.ConnectionName); var durableExtension = GetDurableTaskConfig(); durableExtension.RegisterOrchestrator(new FunctionName("DisabledOrchestrator"), orchestratorInfo: null); var durableClient = (IDurableOrchestrationClient)new DurableClient( @@ -72,7 +72,7 @@ public async Task StartNewAsync_DisabledOrchestrator_ThrowsException() durableExtension.HttpApiHandler, new DurableClientAttribute { }); - ArgumentException exception = await Assert.ThrowsAsync( + ArgumentException exception = await Assert.ThrowsAnyAsync( () => durableClient.StartNewAsync("DisabledOrchestrator")); Assert.Contains("doesn't exist, is disabled, or is not an orchestrator function", exception.Message); @@ -81,6 +81,51 @@ public async Task StartNewAsync_DisabledOrchestrator_ThrowsException() Times.Never()); } + [Fact] + [Trait("Category", PlatformSpecificHelpers.TestCategory)] + public async Task RestartAsync_DisabledOrchestrator_ThrowsException() + { + const string InstanceId = "completed-instance"; + const string FunctionName = "DisabledOrchestrator"; + var orchestrationServiceClientMock = new Mock(); + orchestrationServiceClientMock + .Setup(x => x.GetOrchestrationStateAsync(InstanceId, false)) + .ReturnsAsync( + new List + { + new OrchestrationState + { + Name = FunctionName, + Input = "null", + OrchestrationInstance = new OrchestrationInstance { InstanceId = InstanceId }, + OrchestrationStatus = OrchestrationStatus.Completed, + }, + }); + orchestrationServiceClientMock + .Setup(x => x.CreateTaskOrchestrationAsync(It.IsAny(), It.IsAny())) + .Returns(Task.CompletedTask); + var storageProvider = new DurabilityProvider( + "test", + new Mock().Object, + orchestrationServiceClientMock.Object, + TestConstants.ConnectionName); + var durableExtension = GetDurableTaskConfig(); + durableExtension.RegisterOrchestrator(new FunctionName(FunctionName), orchestratorInfo: null); + var durableClient = (IDurableOrchestrationClient)new DurableClient( + storageProvider, + durableExtension, + durableExtension.HttpApiHandler, + new DurableClientAttribute { }); + + ArgumentException exception = await Assert.ThrowsAnyAsync( + () => durableClient.RestartAsync(InstanceId, restartWithNewInstanceId: false)); + + Assert.Contains("doesn't exist, is disabled, or is not an orchestrator function", exception.Message); + orchestrationServiceClientMock.Verify( + x => x.CreateTaskOrchestrationAsync(It.IsAny(), It.IsAny()), + Times.Never()); + } + [Theory] [Trait("Category", PlatformSpecificHelpers.TestCategory)] [InlineData("@invalid")] @@ -94,7 +139,11 @@ public async Task SignalEntity_InvalidEntityKey_ThrowsException(string entityKey { var orchestrationServiceClientMock = new Mock(); orchestrationServiceClientMock.Setup(x => x.GetOrchestrationStateAsync(It.IsAny(), It.IsAny())).ReturnsAsync(GetInvalidInstanceState()); - var storageProvider = new DurabilityProvider("test", new Mock().Object, orchestrationServiceClientMock.Object, "test"); + var storageProvider = new DurabilityProvider( + "test", + new Mock().Object, + orchestrationServiceClientMock.Object, + TestConstants.ConnectionName); var durableExtension = GetDurableTaskConfig(); var durableClient = (IDurableEntityClient)new DurableClient(storageProvider, durableExtension, durableExtension.HttpApiHandler, new DurableClientAttribute { }); diff --git a/test/FunctionsV2/Tests/Unit/HttpApiHandlerTests.cs b/test/FunctionsV2/Tests/Unit/HttpApiHandlerTests.cs index e23338dbf..bb3bedb3b 100644 --- a/test/FunctionsV2/Tests/Unit/HttpApiHandlerTests.cs +++ b/test/FunctionsV2/Tests/Unit/HttpApiHandlerTests.cs @@ -1315,6 +1315,36 @@ public async Task RestartInstance_Returns_HTTP_400_On_Invalid_InstanceId() Assert.Equal("InstanceId does not match a valid orchestration instance.", error["Message"].ToString()); } + [Fact] + [Trait("Category", PlatformSpecificHelpers.TestCategory)] + public async Task RestartInstance_Returns_HTTP_400_On_Disabled_Function() + { + const string ExceptionMessage = + "The function 'DisabledOrchestrator' doesn't exist, is disabled, or is not an orchestrator function."; + string instanceId = Guid.NewGuid().ToString("N"); + var restartUriBuilder = new UriBuilder(TestConstants.NotificationUrl); + restartUriBuilder.Path += $"/Instances/{instanceId}/restart"; + var request = new HttpRequestMessage + { + Method = HttpMethod.Post, + RequestUri = restartUriBuilder.Uri, + }; + var clientMock = new Mock(); + clientMock + .Setup(x => x.RestartAsync(instanceId, It.IsAny())) + .Throws(new OrchestratorFunctionUnavailableException(ExceptionMessage)); + var httpApiHandler = new ExtendedHttpApiHandler(clientMock.Object); + + HttpResponseMessage response = await httpApiHandler.HandleRequestAsync( + request, + CancellationToken.None); + + Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); + string content = await response.Content.ReadAsStringAsync(); + var error = JsonConvert.DeserializeObject(content); + Assert.Equal(ExceptionMessage, error["Message"].ToString()); + } + [Fact] [Trait("Category", PlatformSpecificHelpers.TestCategory)] public async Task RestartInstance_Returns_HTTP_409_On_Invalid_Existing_Instance() @@ -1948,7 +1978,7 @@ public async Task StartNewInstance_Calls_CreateTaskOrchestrationAsync_With_Corre "storageProviderName", orchestrationServiceMock.Object, orchestrationServiceClientMock.Object, - "connectionName"); + TestConstants.ConnectionName); var options = new DurableTaskOptions { @@ -1994,7 +2024,7 @@ public async Task StartNewInstance_Returns_HTTP_400_On_Disabled_Function() "storageProviderName", orchestrationServiceMock.Object, orchestrationServiceClientMock.Object, - "connectionName"); + TestConstants.ConnectionName); var options = new DurableTaskOptions { WebhookUriProviderOverride = () => new Uri("http://localhost/runtime/webhooks/durabletask"), @@ -2018,13 +2048,17 @@ public async Task StartNewInstance_Returns_HTTP_400_On_Disabled_Function() Times.Never); } - [Fact] + [Theory] + [InlineData("taskHub=RemoteHub", TestConstants.ConnectionName)] + [InlineData("connection=TestConnection", TestConstants.CustomConnectionName)] [Trait("Category", PlatformSpecificHelpers.TestCategory)] - public async Task StartNewInstance_ExternalTaskHub_DoesNotValidateLocalFunction() + public async Task StartNewInstance_ExternalTarget_DoesNotValidateLocalFunction( + string query, + string providerConnectionName) { const string FunctionName = "RemoteOrchestrator"; var requestUri = new Uri( - $"http://localhost/runtime/webhooks/durabletask/orchestrators/{FunctionName}?taskHub=RemoteHub"); + $"http://localhost/runtime/webhooks/durabletask/orchestrators/{FunctionName}?{query}"); var orchestrationServiceMock = new Mock(MockBehavior.Strict); var orchestrationServiceClientMock = new Mock(); orchestrationServiceClientMock @@ -2036,7 +2070,7 @@ public async Task StartNewInstance_ExternalTaskHub_DoesNotValidateLocalFunction( "storageProviderName", orchestrationServiceMock.Object, orchestrationServiceClientMock.Object, - "connectionName"); + providerConnectionName); var options = new DurableTaskOptions { WebhookUriProviderOverride = () => new Uri("http://localhost/runtime/webhooks/durabletask"), diff --git a/test/FunctionsV2/Tests/Unit/LocalGrpcListenerTests.cs b/test/FunctionsV2/Tests/Unit/LocalGrpcListenerTests.cs index 6701365d2..32f1dab7d 100644 --- a/test/FunctionsV2/Tests/Unit/LocalGrpcListenerTests.cs +++ b/test/FunctionsV2/Tests/Unit/LocalGrpcListenerTests.cs @@ -258,6 +258,111 @@ public async Task TestGrpcListener_RejectsDisabledOrchestrator() Times.Never); } + [Theory] + [InlineData(true)] + [InlineData(false)] + [Trait("Category", PlatformSpecificHelpers.TestCategory)] + public async Task TestGrpcListener_ExternalTarget_DoesNotValidateLocalFunction(bool useRemoteTaskHub) + { + const string FunctionName = "RemoteOrchestrator"; + const string RemoteConnectionName = "RemoteConnection"; + Mock durabilityProvider = CreateDurabilityProviderMock( + new Mock().Object, + new Mock().Object, + useRemoteTaskHub ? "TestConnection" : RemoteConnectionName); + durabilityProvider + .Setup(provider => provider.CreateTaskOrchestrationAsync( + It.IsAny(), + It.IsAny(), + It.IsAny())) + .Returns(Task.CompletedTask); + DurabilityProvider defaultDurabilityProvider = useRemoteTaskHub + ? durabilityProvider.Object + : CreateDurabilityProviderMock( + new Mock().Object, + new Mock().Object, + "DefaultConnection").Object; + using DurableTaskExtension extension = this.CreateExtension( + "CurrentHub", + durabilityProvider.Object, + defaultDurabilityProvider); + extension.RegisterOrchestrator(new FunctionName(FunctionName), orchestratorInfo: null); + ILocalGrpcListener listener = LocalGrpcListener.Create( + extension, + LocalGrpcListenerMode.AspNetCore); + + try + { + await listener.StartAsync(default); + using GrpcChannel channel = GrpcChannel.ForAddress(listener.ListenAddress); + var client = new P.TaskHubSidecarService.TaskHubSidecarServiceClient(channel); + var headers = useRemoteTaskHub + ? new Metadata { { TaskHubMetadataKey, "RemoteHub" } } + : new Metadata { { "Durable-ConnectionName", RemoteConnectionName } }; + + await client.StartInstanceAsync( + new P.CreateInstanceRequest { Name = FunctionName }, + headers).ResponseAsync; + } + finally + { + await listener.StopAsync(default); + } + + durabilityProvider.Verify( + provider => provider.CreateTaskOrchestrationAsync( + It.IsAny(), + It.IsAny(), + It.IsAny()), + Times.Once); + } + + [Fact] + [Trait("Category", PlatformSpecificHelpers.TestCategory)] + public async Task TestGrpcListener_RestartRejectsDisabledOrchestrator() + { + const string InstanceId = "completed-instance"; + const string FunctionName = "DisabledOrchestrator"; + var orchestrationServiceClient = new Mock(); + orchestrationServiceClient + .Setup(client => client.GetOrchestrationStateAsync(InstanceId, false)) + .ReturnsAsync( + new List + { + new OrchestrationState + { + Name = FunctionName, + Input = "null", + OrchestrationInstance = new OrchestrationInstance { InstanceId = InstanceId }, + OrchestrationStatus = OrchestrationStatus.Completed, + }, + }); + Mock durabilityProvider = CreateDurabilityProviderMock( + new Mock().Object, + orchestrationServiceClient.Object); + + RpcException rpcException = await this.InvokeFailingRpcAsync( + "DisabledOrchestratorRestart", + durabilityProvider.Object, + async client => await client.RestartInstanceAsync( + new P.RestartInstanceRequest + { + InstanceId = InstanceId, + RestartWithNewInstanceId = false, + }).ResponseAsync, + extension => extension.RegisterOrchestrator( + new FunctionName(FunctionName), + orchestratorInfo: null)); + + Assert.Equal(StatusCode.InvalidArgument, rpcException.StatusCode); + Assert.Contains("doesn't exist, is disabled, or is not an orchestrator function", rpcException.Status.Detail); + orchestrationServiceClient.Verify( + client => client.CreateTaskOrchestrationAsync( + It.IsAny(), + It.IsAny()), + Times.Never); + } + [Theory] [InlineData(false, nameof(ApplicationException))] [InlineData(true, nameof(OperationCanceledException))] @@ -1022,13 +1127,18 @@ private DurableTaskExtension CreateExtension(DurableTaskOptions options, WorkerR platformInformationService: TestHelpers.GetMockPlatformInformationService(language: runtimeType)); } - private DurableTaskExtension CreateExtension(string hubName, DurabilityProvider durabilityProvider) + private DurableTaskExtension CreateExtension( + string hubName, + DurabilityProvider durabilityProvider, + DurabilityProvider defaultDurabilityProvider = null) { var options = new DurableTaskOptions { HubName = hubName }; var wrappedOptions = new OptionsWrapper(options); var serviceFactory = new Mock(); serviceFactory.SetupGet(factory => factory.Name).Returns(AzureStorageDurabilityProviderFactory.ProviderName); - serviceFactory.Setup(factory => factory.GetDurabilityProvider()).Returns(durabilityProvider); + serviceFactory + .Setup(factory => factory.GetDurabilityProvider()) + .Returns(defaultDurabilityProvider ?? durabilityProvider); serviceFactory .Setup(factory => factory.GetDurabilityProvider(It.IsAny())) .Returns(durabilityProvider); @@ -1171,13 +1281,14 @@ private static DurabilityProvider CreateDurabilityProvider( private static Mock CreateDurabilityProviderMock( IOrchestrationService orchestrationService, - IOrchestrationServiceClient orchestrationServiceClient) + IOrchestrationServiceClient orchestrationServiceClient, + string connectionName = "TestConnection") { var durabilityProvider = new Mock( "Test", orchestrationService, orchestrationServiceClient, - "TestConnection") + connectionName) { CallBase = true, }; From b724942f18a2b04e3c4936675d28aad3dc2cb1f2 Mon Sep 17 00:00:00 2001 From: YunchuWang <12449837+YunchuWang@users.noreply.github.com> Date: Wed, 5 Aug 2026 19:14:37 -0700 Subject: [PATCH 04/13] Match task hub names case-insensitively Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> Copilot-Session: 47efed8f-40ca-43b8-8564-de5406bafbc0 --- .../ContextImplementations/DurableClient.cs | 2 +- .../Tests/Unit/DurableClientBaseTests.cs | 16 ++-- .../Tests/Unit/HttpApiHandlerTests.cs | 73 ++++++++++++++----- .../Tests/Unit/LocalGrpcListenerTests.cs | 24 ++++-- 4 files changed, 82 insertions(+), 33 deletions(-) diff --git a/src/WebJobs.Extensions.DurableTask/ContextImplementations/DurableClient.cs b/src/WebJobs.Extensions.DurableTask/ContextImplementations/DurableClient.cs index ce4861f48..f43460a05 100644 --- a/src/WebJobs.Extensions.DurableTask/ContextImplementations/DurableClient.cs +++ b/src/WebJobs.Extensions.DurableTask/ContextImplementations/DurableClient.cs @@ -369,7 +369,7 @@ internal bool ReferencesCurrentApp() private bool TaskHubMatchesCurrentApp(DurableClient client) { var taskHubName = this.durableTaskOptions.HubName; - return client.TaskHubName.Equals(taskHubName); + return string.Equals(client.TaskHubName, taskHubName, StringComparison.OrdinalIgnoreCase); } private bool ConnectionNameMatchesCurrentApp(DurableClient client) diff --git a/test/FunctionsV2/Tests/Unit/DurableClientBaseTests.cs b/test/FunctionsV2/Tests/Unit/DurableClientBaseTests.cs index 15e7fb698..096ff8481 100644 --- a/test/FunctionsV2/Tests/Unit/DurableClientBaseTests.cs +++ b/test/FunctionsV2/Tests/Unit/DurableClientBaseTests.cs @@ -51,9 +51,11 @@ public async Task StartNewAsync_InvalidInstanceId_ThrowsException(string instanc await Assert.ThrowsAnyAsync(async () => await durableClient.StartNewAsync("anyOrchestratorFunction", instanceId, new { message = "any obj" })); } - [Fact] + [Theory] + [InlineData(null)] + [InlineData("durabletaskhub")] [Trait("Category", PlatformSpecificHelpers.TestCategory)] - public async Task StartNewAsync_DisabledOrchestrator_ThrowsException() + public async Task StartNewAsync_DisabledOrchestrator_ThrowsException(string taskHub) { var orchestrationServiceClientMock = new Mock(); orchestrationServiceClientMock @@ -70,7 +72,7 @@ public async Task StartNewAsync_DisabledOrchestrator_ThrowsException() storageProvider, durableExtension, durableExtension.HttpApiHandler, - new DurableClientAttribute { }); + new DurableClientAttribute { TaskHub = taskHub }); ArgumentException exception = await Assert.ThrowsAnyAsync( () => durableClient.StartNewAsync("DisabledOrchestrator")); @@ -81,9 +83,11 @@ public async Task StartNewAsync_DisabledOrchestrator_ThrowsException() Times.Never()); } - [Fact] + [Theory] + [InlineData(null)] + [InlineData("durabletaskhub")] [Trait("Category", PlatformSpecificHelpers.TestCategory)] - public async Task RestartAsync_DisabledOrchestrator_ThrowsException() + public async Task RestartAsync_DisabledOrchestrator_ThrowsException(string taskHub) { const string InstanceId = "completed-instance"; const string FunctionName = "DisabledOrchestrator"; @@ -115,7 +119,7 @@ public async Task RestartAsync_DisabledOrchestrator_ThrowsException() storageProvider, durableExtension, durableExtension.HttpApiHandler, - new DurableClientAttribute { }); + new DurableClientAttribute { TaskHub = taskHub }); ArgumentException exception = await Assert.ThrowsAnyAsync( () => durableClient.RestartAsync(InstanceId, restartWithNewInstanceId: false)); diff --git a/test/FunctionsV2/Tests/Unit/HttpApiHandlerTests.cs b/test/FunctionsV2/Tests/Unit/HttpApiHandlerTests.cs index bb3bedb3b..820cf8257 100644 --- a/test/FunctionsV2/Tests/Unit/HttpApiHandlerTests.cs +++ b/test/FunctionsV2/Tests/Unit/HttpApiHandlerTests.cs @@ -1315,34 +1315,64 @@ public async Task RestartInstance_Returns_HTTP_400_On_Invalid_InstanceId() Assert.Equal("InstanceId does not match a valid orchestration instance.", error["Message"].ToString()); } - [Fact] + [Theory] + [InlineData(false)] + [InlineData(true)] [Trait("Category", PlatformSpecificHelpers.TestCategory)] - public async Task RestartInstance_Returns_HTTP_400_On_Disabled_Function() + public async Task RestartInstance_Returns_HTTP_400_On_Disabled_Function(bool useCaseVariantTaskHub) { - const string ExceptionMessage = - "The function 'DisabledOrchestrator' doesn't exist, is disabled, or is not an orchestrator function."; - string instanceId = Guid.NewGuid().ToString("N"); - var restartUriBuilder = new UriBuilder(TestConstants.NotificationUrl); - restartUriBuilder.Path += $"/Instances/{instanceId}/restart"; - var request = new HttpRequestMessage + const string InstanceId = "completed-instance"; + const string FunctionName = "DisabledOrchestrator"; + string query = useCaseVariantTaskHub ? $"?taskHub={TestConstants.TaskHub.ToLowerInvariant()}" : string.Empty; + var requestUri = new Uri( + $"http://localhost/runtime/webhooks/durabletask/instances/{InstanceId}/restart{query}"); + var orchestrationServiceMock = new Mock(MockBehavior.Strict); + var orchestrationServiceClientMock = new Mock(); + orchestrationServiceClientMock + .Setup(client => client.GetOrchestrationStateAsync(InstanceId, false)) + .ReturnsAsync( + new List + { + new OrchestrationState + { + Name = FunctionName, + Input = "null", + OrchestrationInstance = new OrchestrationInstance { InstanceId = InstanceId }, + OrchestrationStatus = OrchestrationStatus.Completed, + }, + }); + orchestrationServiceClientMock + .Setup(client => client.CreateTaskOrchestrationAsync( + It.IsAny(), + It.IsAny())) + .Returns(Task.CompletedTask); + var durabilityProvider = new DurabilityProvider( + "storageProviderName", + orchestrationServiceMock.Object, + orchestrationServiceClientMock.Object, + TestConstants.ConnectionName); + var options = new DurableTaskOptions { - Method = HttpMethod.Post, - RequestUri = restartUriBuilder.Uri, + WebhookUriProviderOverride = () => new Uri("http://localhost/runtime/webhooks/durabletask"), + HubName = TestConstants.TaskHub, }; - var clientMock = new Mock(); - clientMock - .Setup(x => x.RestartAsync(instanceId, It.IsAny())) - .Throws(new OrchestratorFunctionUnavailableException(ExceptionMessage)); - var httpApiHandler = new ExtendedHttpApiHandler(clientMock.Object); + var extension = TestDurableTaskExtension.CreateWithProvider(options, durabilityProvider); + extension.RegisterOrchestrator(new FunctionName(FunctionName), orchestratorInfo: null); + var httpApiHandler = new HttpApiHandler(extension, NullLogger.Instance); HttpResponseMessage response = await httpApiHandler.HandleRequestAsync( - request, + new HttpRequestMessage(HttpMethod.Post, requestUri), CancellationToken.None); Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); string content = await response.Content.ReadAsStringAsync(); var error = JsonConvert.DeserializeObject(content); - Assert.Equal(ExceptionMessage, error["Message"].ToString()); + Assert.Contains("doesn't exist, is disabled, or is not an orchestrator function", error["Message"].ToString()); + orchestrationServiceClientMock.Verify( + client => client.CreateTaskOrchestrationAsync( + It.IsAny(), + It.IsAny()), + Times.Never); } [Fact] @@ -2006,13 +2036,16 @@ public async Task StartNewInstance_Calls_CreateTaskOrchestrationAsync_With_Corre Assert.Equal(expectedVersion, capturedEvent.Version); } - [Fact] + [Theory] + [InlineData(false)] + [InlineData(true)] [Trait("Category", PlatformSpecificHelpers.TestCategory)] - public async Task StartNewInstance_Returns_HTTP_400_On_Disabled_Function() + public async Task StartNewInstance_Returns_HTTP_400_On_Disabled_Function(bool useCaseVariantTaskHub) { const string FunctionName = "DisabledOrchestrator"; + string query = useCaseVariantTaskHub ? $"?taskHub={TestConstants.TaskHub.ToLowerInvariant()}" : string.Empty; var requestUri = new Uri( - $"http://localhost/runtime/webhooks/durabletask/orchestrators/{FunctionName}"); + $"http://localhost/runtime/webhooks/durabletask/orchestrators/{FunctionName}{query}"); var orchestrationServiceMock = new Mock(MockBehavior.Strict); var orchestrationServiceClientMock = new Mock(); orchestrationServiceClientMock diff --git a/test/FunctionsV2/Tests/Unit/LocalGrpcListenerTests.cs b/test/FunctionsV2/Tests/Unit/LocalGrpcListenerTests.cs index 32f1dab7d..4cae78cd6 100644 --- a/test/FunctionsV2/Tests/Unit/LocalGrpcListenerTests.cs +++ b/test/FunctionsV2/Tests/Unit/LocalGrpcListenerTests.cs @@ -224,11 +224,16 @@ public async Task TestGrpcListener_DoesNotLogStartInstanceClientCancellation() message.FormattedMessage.Contains("StartInstance")); } - [Fact] + [Theory] + [InlineData(false)] + [InlineData(true)] [Trait("Category", PlatformSpecificHelpers.TestCategory)] - public async Task TestGrpcListener_RejectsDisabledOrchestrator() + public async Task TestGrpcListener_RejectsDisabledOrchestrator(bool useCaseVariantTaskHub) { const string FunctionName = "DisabledOrchestrator"; + Metadata headers = useCaseVariantTaskHub + ? new Metadata { { TaskHubMetadataKey, "disabledorchestratorstart" } } + : null; Mock durabilityProvider = CreateDurabilityProviderMock( new Mock().Object, new Mock().Object); @@ -243,7 +248,8 @@ public async Task TestGrpcListener_RejectsDisabledOrchestrator() "DisabledOrchestratorStart", durabilityProvider.Object, async client => await client.StartInstanceAsync( - new P.CreateInstanceRequest { Name = FunctionName }).ResponseAsync, + new P.CreateInstanceRequest { Name = FunctionName }, + headers).ResponseAsync, extension => extension.RegisterOrchestrator( new FunctionName(FunctionName), orchestratorInfo: null)); @@ -317,12 +323,17 @@ await client.StartInstanceAsync( Times.Once); } - [Fact] + [Theory] + [InlineData(false)] + [InlineData(true)] [Trait("Category", PlatformSpecificHelpers.TestCategory)] - public async Task TestGrpcListener_RestartRejectsDisabledOrchestrator() + public async Task TestGrpcListener_RestartRejectsDisabledOrchestrator(bool useCaseVariantTaskHub) { const string InstanceId = "completed-instance"; const string FunctionName = "DisabledOrchestrator"; + Metadata headers = useCaseVariantTaskHub + ? new Metadata { { TaskHubMetadataKey, "disabledorchestratorrestart" } } + : null; var orchestrationServiceClient = new Mock(); orchestrationServiceClient .Setup(client => client.GetOrchestrationStateAsync(InstanceId, false)) @@ -349,7 +360,8 @@ public async Task TestGrpcListener_RestartRejectsDisabledOrchestrator() { InstanceId = InstanceId, RestartWithNewInstanceId = false, - }).ResponseAsync, + }, + headers).ResponseAsync, extension => extension.RegisterOrchestrator( new FunctionName(FunctionName), orchestratorInfo: null)); From 3b28148efe3c98aa593cdde6f69a0780368b2beb Mon Sep 17 00:00:00 2001 From: YunchuWang <12449837+YunchuWang@users.noreply.github.com> Date: Wed, 5 Aug 2026 19:52:39 -0700 Subject: [PATCH 05/13] Clarify current-app availability checks Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> Copilot-Session: 47efed8f-40ca-43b8-8564-de5406bafbc0 --- .../ContextImplementations/DurableClient.cs | 4 +- .../DurableTaskExtension.cs | 9 ++++- .../HttpApiHandler.cs | 2 +- .../TaskHubGrpcServer.cs | 2 +- .../Unit/DisabledFunctionDispatchTests.cs | 4 +- .../Tests/Unit/DurableClientBaseTests.cs | 37 +++++++++++++++++++ 6 files changed, 50 insertions(+), 8 deletions(-) diff --git a/src/WebJobs.Extensions.DurableTask/ContextImplementations/DurableClient.cs b/src/WebJobs.Extensions.DurableTask/ContextImplementations/DurableClient.cs index f43460a05..c5b7c3972 100644 --- a/src/WebJobs.Extensions.DurableTask/ContextImplementations/DurableClient.cs +++ b/src/WebJobs.Extensions.DurableTask/ContextImplementations/DurableClient.cs @@ -178,7 +178,7 @@ async Task IDurableOrchestrationClient.StartNewAsync(string orchestra { if (this.ReferencesCurrentApp()) { - this.config?.ThrowIfOrchestratorFunctionIsUnavailable(orchestratorFunctionName); + this.config?.ThrowIfOrchestratorFunctionIsMissingOrDisabled(orchestratorFunctionName); } if (string.IsNullOrEmpty(instanceId)) @@ -1265,7 +1265,7 @@ async Task IDurableOrchestrationClient.RestartAsync(string instanceId, b if (this.ReferencesCurrentApp()) { - this.config?.ThrowIfOrchestratorFunctionIsUnavailable(state.Name); + this.config?.ThrowIfOrchestratorFunctionIsMissingOrDisabled(state.Name); } JToken input = ParseToJToken(state.Input); diff --git a/src/WebJobs.Extensions.DurableTask/DurableTaskExtension.cs b/src/WebJobs.Extensions.DurableTask/DurableTaskExtension.cs index 9bd495121..dcf359745 100644 --- a/src/WebJobs.Extensions.DurableTask/DurableTaskExtension.cs +++ b/src/WebJobs.Extensions.DurableTask/DurableTaskExtension.cs @@ -1495,9 +1495,14 @@ internal void ThrowIfFunctionDoesNotExist(string name, FunctionType functionType } } - internal void ThrowIfOrchestratorFunctionIsUnavailable(string name) + internal void ThrowIfOrchestratorFunctionIsMissingOrDisabled(string name) { - if (this.GetOrchestratorInfo(new FunctionName(name)) == null) + RegisteredFunctionInfo info = this.GetOrchestratorInfo(new FunctionName(name)); + + // A null registration means the function was indexed but disabled, so its listener was + // never created. IsDeregistered is deliberately allowed because it represents transient, + // instance-local listener shutdown; the durable start can run on another or restarted host. + if (info == null) { throw new OrchestratorFunctionUnavailableException(this.GetInvalidOrchestratorFunctionMessage(name)); } diff --git a/src/WebJobs.Extensions.DurableTask/HttpApiHandler.cs b/src/WebJobs.Extensions.DurableTask/HttpApiHandler.cs index 4649d3c88..662ee40b0 100644 --- a/src/WebJobs.Extensions.DurableTask/HttpApiHandler.cs +++ b/src/WebJobs.Extensions.DurableTask/HttpApiHandler.cs @@ -959,7 +959,7 @@ private async Task HandleStartOrchestratorRequestAsync( { if (durableClient.ReferencesCurrentApp()) { - this.config.ThrowIfOrchestratorFunctionIsUnavailable(functionName); + this.config.ThrowIfOrchestratorFunctionIsMissingOrDisabled(functionName); } var instance = new OrchestrationInstance diff --git a/src/WebJobs.Extensions.DurableTask/TaskHubGrpcServer.cs b/src/WebJobs.Extensions.DurableTask/TaskHubGrpcServer.cs index 5261952df..ef9f8bd08 100644 --- a/src/WebJobs.Extensions.DurableTask/TaskHubGrpcServer.cs +++ b/src/WebJobs.Extensions.DurableTask/TaskHubGrpcServer.cs @@ -61,7 +61,7 @@ public override Task Hello(Empty request, ServerCallContext context) { if (this.GetClient(context) is DurableClient durableClient && durableClient.ReferencesCurrentApp()) { - this.extension.ThrowIfOrchestratorFunctionIsUnavailable(request.Name); + this.extension.ThrowIfOrchestratorFunctionIsMissingOrDisabled(request.Name); } List allStatuses = System.Enum diff --git a/test/FunctionsV2/Tests/Unit/DisabledFunctionDispatchTests.cs b/test/FunctionsV2/Tests/Unit/DisabledFunctionDispatchTests.cs index 4ff69dd8f..8b95a36d2 100644 --- a/test/FunctionsV2/Tests/Unit/DisabledFunctionDispatchTests.cs +++ b/test/FunctionsV2/Tests/Unit/DisabledFunctionDispatchTests.cs @@ -93,7 +93,7 @@ public void GetObject_ActiveActivity_ReturnsRealActivityShim() [Fact] [Trait("Category", PlatformSpecificHelpers.TestCategory)] - public void ThrowIfOrchestratorFunctionIsUnavailable_ActiveOutOfProcOrchestrator_DoesNotThrow() + public void ThrowIfOrchestratorFunctionIsMissingOrDisabled_ActiveOutOfProcOrchestrator_DoesNotThrow() { var extension = CreateExtension(); var mockExecutor = new Mock(); @@ -101,7 +101,7 @@ public void ThrowIfOrchestratorFunctionIsUnavailable_ActiveOutOfProcOrchestrator new FunctionName("ActiveOrchestrator"), new RegisteredFunctionInfo(mockExecutor.Object, isOutOfProc: true)); - extension.ThrowIfOrchestratorFunctionIsUnavailable("ActiveOrchestrator"); + extension.ThrowIfOrchestratorFunctionIsMissingOrDisabled("ActiveOrchestrator"); } [Fact] diff --git a/test/FunctionsV2/Tests/Unit/DurableClientBaseTests.cs b/test/FunctionsV2/Tests/Unit/DurableClientBaseTests.cs index 096ff8481..724f2567c 100644 --- a/test/FunctionsV2/Tests/Unit/DurableClientBaseTests.cs +++ b/test/FunctionsV2/Tests/Unit/DurableClientBaseTests.cs @@ -130,6 +130,43 @@ public async Task RestartAsync_DisabledOrchestrator_ThrowsException(string taskH Times.Never()); } + [Fact] + [Trait("Category", PlatformSpecificHelpers.TestCategory)] + public async Task StartNewAsync_DeregisteredOrchestrator_SchedulesInstance() + { + const string FunctionName = "DrainingOrchestrator"; + const string InstanceId = "new-instance"; + var orchestrationServiceClientMock = new Mock(); + orchestrationServiceClientMock + .Setup(x => x.CreateTaskOrchestrationAsync(It.IsAny(), It.IsAny())) + .Returns(Task.CompletedTask); + var storageProvider = new DurabilityProvider( + "test", + new Mock().Object, + orchestrationServiceClientMock.Object, + TestConstants.ConnectionName); + var durableExtension = GetDurableTaskConfig(); + var functionName = new FunctionName(FunctionName); + durableExtension.RegisterOrchestrator( + functionName, + new RegisteredFunctionInfo(executor: null, isOutOfProc: true)); + durableExtension.DeregisterOrchestrator(functionName); + var durableClient = (IDurableOrchestrationClient)new DurableClient( + storageProvider, + durableExtension, + durableExtension.HttpApiHandler, + new DurableClientAttribute { }); + + string actualInstanceId = await durableClient.StartNewAsync( + FunctionName, + InstanceId); + + Assert.Equal(InstanceId, actualInstanceId); + orchestrationServiceClientMock.Verify( + x => x.CreateTaskOrchestrationAsync(It.IsAny(), It.IsAny()), + Times.Once()); + } + [Theory] [Trait("Category", PlatformSpecificHelpers.TestCategory)] [InlineData("@invalid")] From abecce5e51d17df496a231950c4de9753a5b60ff Mon Sep 17 00:00:00 2001 From: YunchuWang <12449837+YunchuWang@users.noreply.github.com> Date: Wed, 5 Aug 2026 21:45:52 -0700 Subject: [PATCH 06/13] Preserve starts for unknown orchestrators Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> Copilot-Session: 47efed8f-40ca-43b8-8564-de5406bafbc0 --- .../ContextImplementations/DurableClient.cs | 5 ++-- .../DurableTaskExtension.cs | 11 ++++--- .../HttpApiHandler.cs | 2 +- .../TaskHubGrpcServer.cs | 2 +- .../Unit/DisabledFunctionDispatchTests.cs | 13 +++++++-- .../Tests/Unit/DurableClientBaseTests.cs | 29 +++++++++++++++++++ 6 files changed, 50 insertions(+), 12 deletions(-) diff --git a/src/WebJobs.Extensions.DurableTask/ContextImplementations/DurableClient.cs b/src/WebJobs.Extensions.DurableTask/ContextImplementations/DurableClient.cs index c5b7c3972..e2e6bbd2b 100644 --- a/src/WebJobs.Extensions.DurableTask/ContextImplementations/DurableClient.cs +++ b/src/WebJobs.Extensions.DurableTask/ContextImplementations/DurableClient.cs @@ -178,7 +178,8 @@ async Task IDurableOrchestrationClient.StartNewAsync(string orchestra { if (this.ReferencesCurrentApp()) { - this.config?.ThrowIfOrchestratorFunctionIsMissingOrDisabled(orchestratorFunctionName); + this.config?.ThrowIfFunctionDoesNotExist(orchestratorFunctionName, FunctionType.Orchestrator); + this.config?.ThrowIfOrchestratorFunctionIsDisabled(orchestratorFunctionName); } if (string.IsNullOrEmpty(instanceId)) @@ -1265,7 +1266,7 @@ async Task IDurableOrchestrationClient.RestartAsync(string instanceId, b if (this.ReferencesCurrentApp()) { - this.config?.ThrowIfOrchestratorFunctionIsMissingOrDisabled(state.Name); + this.config?.ThrowIfOrchestratorFunctionIsDisabled(state.Name); } JToken input = ParseToJToken(state.Input); diff --git a/src/WebJobs.Extensions.DurableTask/DurableTaskExtension.cs b/src/WebJobs.Extensions.DurableTask/DurableTaskExtension.cs index dcf359745..6b2e1c1b5 100644 --- a/src/WebJobs.Extensions.DurableTask/DurableTaskExtension.cs +++ b/src/WebJobs.Extensions.DurableTask/DurableTaskExtension.cs @@ -1495,14 +1495,13 @@ internal void ThrowIfFunctionDoesNotExist(string name, FunctionType functionType } } - internal void ThrowIfOrchestratorFunctionIsMissingOrDisabled(string name) + internal void ThrowIfOrchestratorFunctionIsDisabled(string name) { - RegisteredFunctionInfo info = this.GetOrchestratorInfo(new FunctionName(name)); - // A null registration means the function was indexed but disabled, so its listener was - // never created. IsDeregistered is deliberately allowed because it represents transient, - // instance-local listener shutdown; the durable start can run on another or restarted host. - if (info == null) + // never created. A missing registration and IsDeregistered are deliberately allowed: + // the target may exist in another app, or its listener may be restarting on this host. + if (this.knownOrchestrators.TryGetValue(new FunctionName(name), out RegisteredFunctionInfo info) && + info == null) { throw new OrchestratorFunctionUnavailableException(this.GetInvalidOrchestratorFunctionMessage(name)); } diff --git a/src/WebJobs.Extensions.DurableTask/HttpApiHandler.cs b/src/WebJobs.Extensions.DurableTask/HttpApiHandler.cs index 662ee40b0..4f674dd4b 100644 --- a/src/WebJobs.Extensions.DurableTask/HttpApiHandler.cs +++ b/src/WebJobs.Extensions.DurableTask/HttpApiHandler.cs @@ -959,7 +959,7 @@ private async Task HandleStartOrchestratorRequestAsync( { if (durableClient.ReferencesCurrentApp()) { - this.config.ThrowIfOrchestratorFunctionIsMissingOrDisabled(functionName); + this.config.ThrowIfOrchestratorFunctionIsDisabled(functionName); } var instance = new OrchestrationInstance diff --git a/src/WebJobs.Extensions.DurableTask/TaskHubGrpcServer.cs b/src/WebJobs.Extensions.DurableTask/TaskHubGrpcServer.cs index ef9f8bd08..9061e481a 100644 --- a/src/WebJobs.Extensions.DurableTask/TaskHubGrpcServer.cs +++ b/src/WebJobs.Extensions.DurableTask/TaskHubGrpcServer.cs @@ -61,7 +61,7 @@ public override Task Hello(Empty request, ServerCallContext context) { if (this.GetClient(context) is DurableClient durableClient && durableClient.ReferencesCurrentApp()) { - this.extension.ThrowIfOrchestratorFunctionIsMissingOrDisabled(request.Name); + this.extension.ThrowIfOrchestratorFunctionIsDisabled(request.Name); } List allStatuses = System.Enum diff --git a/test/FunctionsV2/Tests/Unit/DisabledFunctionDispatchTests.cs b/test/FunctionsV2/Tests/Unit/DisabledFunctionDispatchTests.cs index 8b95a36d2..7e50d6b40 100644 --- a/test/FunctionsV2/Tests/Unit/DisabledFunctionDispatchTests.cs +++ b/test/FunctionsV2/Tests/Unit/DisabledFunctionDispatchTests.cs @@ -93,7 +93,7 @@ public void GetObject_ActiveActivity_ReturnsRealActivityShim() [Fact] [Trait("Category", PlatformSpecificHelpers.TestCategory)] - public void ThrowIfOrchestratorFunctionIsMissingOrDisabled_ActiveOutOfProcOrchestrator_DoesNotThrow() + public void ThrowIfOrchestratorFunctionIsDisabled_ActiveOutOfProcOrchestrator_DoesNotThrow() { var extension = CreateExtension(); var mockExecutor = new Mock(); @@ -101,7 +101,16 @@ public void ThrowIfOrchestratorFunctionIsMissingOrDisabled_ActiveOutOfProcOrches new FunctionName("ActiveOrchestrator"), new RegisteredFunctionInfo(mockExecutor.Object, isOutOfProc: true)); - extension.ThrowIfOrchestratorFunctionIsMissingOrDisabled("ActiveOrchestrator"); + extension.ThrowIfOrchestratorFunctionIsDisabled("ActiveOrchestrator"); + } + + [Fact] + [Trait("Category", PlatformSpecificHelpers.TestCategory)] + public void ThrowIfOrchestratorFunctionIsDisabled_MissingOrchestrator_DoesNotThrow() + { + var extension = CreateExtension(); + + extension.ThrowIfOrchestratorFunctionIsDisabled("MissingOrchestrator"); } [Fact] diff --git a/test/FunctionsV2/Tests/Unit/DurableClientBaseTests.cs b/test/FunctionsV2/Tests/Unit/DurableClientBaseTests.cs index 724f2567c..69beacfe4 100644 --- a/test/FunctionsV2/Tests/Unit/DurableClientBaseTests.cs +++ b/test/FunctionsV2/Tests/Unit/DurableClientBaseTests.cs @@ -51,6 +51,35 @@ public async Task StartNewAsync_InvalidInstanceId_ThrowsException(string instanc await Assert.ThrowsAnyAsync(async () => await durableClient.StartNewAsync("anyOrchestratorFunction", instanceId, new { message = "any obj" })); } + [Fact] + [Trait("Category", PlatformSpecificHelpers.TestCategory)] + public async Task StartNewAsync_MissingOrchestrator_ThrowsException() + { + var orchestrationServiceClientMock = new Mock(); + orchestrationServiceClientMock + .Setup(x => x.CreateTaskOrchestrationAsync(It.IsAny(), It.IsAny())) + .Returns(Task.CompletedTask); + var storageProvider = new DurabilityProvider( + "test", + new Mock().Object, + orchestrationServiceClientMock.Object, + TestConstants.ConnectionName); + var durableExtension = GetDurableTaskConfig(); + var durableClient = (IDurableOrchestrationClient)new DurableClient( + storageProvider, + durableExtension, + durableExtension.HttpApiHandler, + new DurableClientAttribute()); + + ArgumentException exception = await Assert.ThrowsAnyAsync( + () => durableClient.StartNewAsync("MissingOrchestrator")); + + Assert.Contains("doesn't exist, is disabled, or is not an orchestrator function", exception.Message); + orchestrationServiceClientMock.Verify( + x => x.CreateTaskOrchestrationAsync(It.IsAny(), It.IsAny()), + Times.Never()); + } + [Theory] [InlineData(null)] [InlineData("durabletaskhub")] From a45586500082b443ce8c6681d1f2d73ee2bdae04 Mon Sep 17 00:00:00 2001 From: wangbill Date: Fri, 14 Aug 2026 09:36:31 -0700 Subject: [PATCH 07/13] Fix disabled orchestrator start validation Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> Copilot-Session: 7cf4a7ba-c821-42dd-ba14-0333dddc5356 --- .../ContextImplementations/DurableClient.cs | 14 +- .../IDurableOrchestrationClient.cs | 3 + .../DurabilityProvider.cs | 4 +- .../TaskHubGrpcServer.cs | 18 +-- .../Tests/Unit/DurableClientBaseTests.cs | 127 ++++++++++++++-- .../Tests/Unit/HttpApiHandlerTests.cs | 1 + .../Tests/Unit/LocalGrpcListenerTests.cs | 24 ++- .../Tests/Tests/DisabledOrchestrationTests.cs | 139 ++++++++++++++++++ 8 files changed, 304 insertions(+), 26 deletions(-) diff --git a/src/WebJobs.Extensions.DurableTask/ContextImplementations/DurableClient.cs b/src/WebJobs.Extensions.DurableTask/ContextImplementations/DurableClient.cs index cc00e8be7..dd9316c2c 100644 --- a/src/WebJobs.Extensions.DurableTask/ContextImplementations/DurableClient.cs +++ b/src/WebJobs.Extensions.DurableTask/ContextImplementations/DurableClient.cs @@ -30,6 +30,8 @@ internal class DurableClient : IDurableClient, #pragma warning restore 618 { private const int MaxInstanceIdLength = 256; + private const string AzureStorageProviderName = "Azure Storage"; + private const string AzureManagedProviderName = "azureManaged"; private static readonly JValue NullJValue = JValue.CreateNull(); private static readonly OrchestrationRuntimeStatus[] RunningStatus @@ -370,7 +372,17 @@ internal bool ReferencesCurrentApp() private bool TaskHubMatchesCurrentApp(DurableClient client) { var taskHubName = this.durableTaskOptions.HubName; - return string.Equals(client.TaskHubName, taskHubName, StringComparison.OrdinalIgnoreCase); + StringComparison comparison = UsesCaseInsensitiveTaskHubNames(this.config?.DefaultDurabilityProvider) + ? StringComparison.OrdinalIgnoreCase + : StringComparison.Ordinal; + return string.Equals(client.TaskHubName, taskHubName, comparison); + } + + private static bool UsesCaseInsensitiveTaskHubNames(DurabilityProvider provider) + { + return provider != null && + (string.Equals(provider.Name, AzureStorageProviderName, StringComparison.OrdinalIgnoreCase) || + string.Equals(provider.Name, AzureManagedProviderName, StringComparison.OrdinalIgnoreCase)); } private bool ConnectionNameMatchesCurrentApp(DurableClient client) diff --git a/src/WebJobs.Extensions.DurableTask/ContextInterfaces/IDurableOrchestrationClient.cs b/src/WebJobs.Extensions.DurableTask/ContextInterfaces/IDurableOrchestrationClient.cs index 8a89e9861..16a53a6cb 100644 --- a/src/WebJobs.Extensions.DurableTask/ContextInterfaces/IDurableOrchestrationClient.cs +++ b/src/WebJobs.Extensions.DurableTask/ContextInterfaces/IDurableOrchestrationClient.cs @@ -349,6 +349,9 @@ Task StartNewAsync( /// reuse the old instanceId. Defaults to true. /// A task that completes when the orchestration is started. The task contains the instance id of the started /// orchestration instance. + /// + /// The orchestrator function for the specified instance is disabled. + /// Task RestartAsync(string instanceId, bool restartWithNewInstanceId = true); /// diff --git a/src/WebJobs.Extensions.DurableTask/DurabilityProvider.cs b/src/WebJobs.Extensions.DurableTask/DurabilityProvider.cs index 5d27d59d8..ca41355da 100644 --- a/src/WebJobs.Extensions.DurableTask/DurabilityProvider.cs +++ b/src/WebJobs.Extensions.DurableTask/DurabilityProvider.cs @@ -66,6 +66,8 @@ public DurabilityProvider(string storageProviderName, IOrchestrationService serv /// public virtual string ConnectionName => this.connectionName; + internal string Name => this.name; + /// /// Specifies whether the durability provider supports Durable Entities. /// @@ -613,7 +615,7 @@ public virtual bool ValidateDelayTime(TimeSpan timespan, out string errorMessage /// A boolean indicating whether the connection names match. internal virtual bool ConnectionNameMatches(DurabilityProvider durabilityProvider) { - return this.ConnectionName.Equals(durabilityProvider.ConnectionName); + return string.Equals(this.ConnectionName, durabilityProvider.ConnectionName, StringComparison.OrdinalIgnoreCase); } /// diff --git a/src/WebJobs.Extensions.DurableTask/TaskHubGrpcServer.cs b/src/WebJobs.Extensions.DurableTask/TaskHubGrpcServer.cs index 9061e481a..04f4368fc 100644 --- a/src/WebJobs.Extensions.DurableTask/TaskHubGrpcServer.cs +++ b/src/WebJobs.Extensions.DurableTask/TaskHubGrpcServer.cs @@ -59,6 +59,14 @@ public override Task Hello(Empty request, ServerCallContext context) { try { + var instance = new OrchestrationInstance + { + InstanceId = string.IsNullOrEmpty(request.InstanceId) ? Guid.NewGuid().ToString("N") : request.InstanceId, + ExecutionId = Guid.NewGuid().ToString(), + }; + + this.LogClientOperationReceived(context, "StartOrchestration", instance.InstanceId); + if (this.GetClient(context) is DurableClient durableClient && durableClient.ReferencesCurrentApp()) { this.extension.ThrowIfOrchestratorFunctionIsDisabled(request.Name); @@ -80,16 +88,6 @@ public override Task Hello(Empty request, ServerCallContext context) .Union(this.extension.Options.OverridableExistingInstanceStates.ToDedupeStatuses()) .ToArray(); - // Create the orchestration instance - var instance = new OrchestrationInstance - { - InstanceId = string.IsNullOrEmpty(request.InstanceId) ? Guid.NewGuid().ToString("N") : request.InstanceId, - ExecutionId = Guid.NewGuid().ToString(), - }; - - // Log correlation information for client operations - this.LogClientOperationReceived(context, "StartOrchestration", instance.InstanceId); - // Create the ExecutionStartedEvent ExecutionStartedEvent executionStartedEvent = new ExecutionStartedEvent(-1, request.Input) { diff --git a/test/FunctionsV2/Tests/Unit/DurableClientBaseTests.cs b/test/FunctionsV2/Tests/Unit/DurableClientBaseTests.cs index 69beacfe4..2fb94d6ad 100644 --- a/test/FunctionsV2/Tests/Unit/DurableClientBaseTests.cs +++ b/test/FunctionsV2/Tests/Unit/DurableClientBaseTests.cs @@ -81,21 +81,31 @@ public async Task StartNewAsync_MissingOrchestrator_ThrowsException() } [Theory] - [InlineData(null)] - [InlineData("durabletaskhub")] + [InlineData("Azure Storage", null, true)] + [InlineData("Azure Storage", "durabletaskhub", true)] + [InlineData("azureManaged", "durabletaskhub", true)] + [InlineData("mssql", "durabletaskhub", false)] + [InlineData("mssql", "DurableTaskHub", true)] + [InlineData("Netherite", "durabletaskhub", false)] + [InlineData("Netherite", "DurableTaskHub", true)] + [InlineData("custom", "durabletaskhub", false)] + [InlineData("custom", "DurableTaskHub", true)] [Trait("Category", PlatformSpecificHelpers.TestCategory)] - public async Task StartNewAsync_DisabledOrchestrator_ThrowsException(string taskHub) + public async Task StartNewAsync_DisabledOrchestrator_UsesDefaultProviderTaskHubCaseSensitivity( + string defaultProviderName, + string taskHub, + bool rejectStart) { var orchestrationServiceClientMock = new Mock(); orchestrationServiceClientMock .Setup(x => x.CreateTaskOrchestrationAsync(It.IsAny(), It.IsAny())) .Returns(Task.CompletedTask); var storageProvider = new DurabilityProvider( - "test", + "clientProvider", new Mock().Object, orchestrationServiceClientMock.Object, TestConstants.ConnectionName); - var durableExtension = GetDurableTaskConfig(); + var durableExtension = GetDurableTaskConfig(defaultProviderName); durableExtension.RegisterOrchestrator(new FunctionName("DisabledOrchestrator"), orchestratorInfo: null); var durableClient = (IDurableOrchestrationClient)new DurableClient( storageProvider, @@ -103,13 +113,20 @@ public async Task StartNewAsync_DisabledOrchestrator_ThrowsException(string task durableExtension.HttpApiHandler, new DurableClientAttribute { TaskHub = taskHub }); - ArgumentException exception = await Assert.ThrowsAnyAsync( - () => durableClient.StartNewAsync("DisabledOrchestrator")); + if (rejectStart) + { + ArgumentException exception = await Assert.ThrowsAnyAsync( + () => durableClient.StartNewAsync("DisabledOrchestrator")); + Assert.Contains("doesn't exist, is disabled, or is not an orchestrator function", exception.Message); + } + else + { + await durableClient.StartNewAsync("DisabledOrchestrator"); + } - Assert.Contains("doesn't exist, is disabled, or is not an orchestrator function", exception.Message); orchestrationServiceClientMock.Verify( x => x.CreateTaskOrchestrationAsync(It.IsAny(), It.IsAny()), - Times.Never()); + rejectStart ? Times.Never() : Times.Once()); } [Theory] @@ -221,6 +238,69 @@ public async Task SignalEntity_InvalidEntityKey_ThrowsException(string entityKey await Assert.ThrowsAnyAsync(async () => await durableClient.SignalEntityAsync(entityId, "test")); } + [Theory] + [InlineData(null, TestConstants.ConnectionName)] + [InlineData("durabletaskhub", TestConstants.ConnectionName)] + [InlineData(null, "storage")] + [Trait("Category", PlatformSpecificHelpers.TestCategory)] + public async Task SignalEntityAsync_CurrentAppMissingEntity_ThrowsException( + string taskHub, + string connectionName) + { + var orchestrationServiceClientMock = new Mock(); + orchestrationServiceClientMock + .Setup(client => client.SendTaskOrchestrationMessageAsync(It.IsAny())) + .Returns(Task.CompletedTask); + var storageProvider = new DurabilityProvider( + "test", + new Mock().Object, + orchestrationServiceClientMock.Object, + connectionName); + var durableExtension = GetDurableTaskConfig(); + var durableClient = (IDurableEntityClient)new DurableClient( + storageProvider, + durableExtension, + durableExtension.HttpApiHandler, + new DurableClientAttribute { TaskHub = taskHub }); + + await Assert.ThrowsAnyAsync( + () => durableClient.SignalEntityAsync(new EntityId("MissingEntity", "key"), "operation")); + orchestrationServiceClientMock.Verify( + client => client.SendTaskOrchestrationMessageAsync(It.IsAny()), + Times.Never); + } + + [Theory] + [InlineData("RemoteHub", TestConstants.ConnectionName)] + [InlineData(null, TestConstants.CustomConnectionName)] + [Trait("Category", PlatformSpecificHelpers.TestCategory)] + public async Task SignalEntityAsync_ExternalTarget_DoesNotValidateLocalEntity( + string taskHub, + string connectionName) + { + var orchestrationServiceClientMock = new Mock(); + orchestrationServiceClientMock + .Setup(client => client.SendTaskOrchestrationMessageAsync(It.IsAny())) + .Returns(Task.CompletedTask); + var storageProvider = new DurabilityProvider( + "test", + new Mock().Object, + orchestrationServiceClientMock.Object, + connectionName); + var durableExtension = GetDurableTaskConfig(); + var durableClient = (IDurableEntityClient)new DurableClient( + storageProvider, + durableExtension, + durableExtension.HttpApiHandler, + new DurableClientAttribute { TaskHub = taskHub }); + + await durableClient.SignalEntityAsync(new EntityId("RemoteEntity", "key"), "operation"); + + orchestrationServiceClientMock.Verify( + client => client.SendTaskOrchestrationMessageAsync(It.IsAny()), + Times.Once); + } + [Theory] [Trait("Category", PlatformSpecificHelpers.TestCategory)] [InlineData(false)] @@ -584,6 +664,35 @@ private static DurableTaskExtension GetDurableTaskConfig() platformInformationService: platformInformationService); } + private static DurableTaskExtension GetDurableTaskConfig(string defaultProviderName) + { + var options = new DurableTaskOptions + { + HubName = "DurableTaskHub", + WebhookUriProviderOverride = () => new Uri("https://sampleurl.net"), + }; + options.StorageProvider["type"] = defaultProviderName; + var wrappedOptions = new OptionsWrapper(options); + var nameResolver = TestHelpers.GetTestNameResolver(); + var platformInformationService = TestHelpers.GetMockPlatformInformationService(); + var defaultProvider = new DurabilityProvider( + defaultProviderName, + new Mock().Object, + new Mock().Object, + TestConstants.ConnectionName); + var serviceFactory = new Mock(); + serviceFactory.SetupGet(factory => factory.Name).Returns(defaultProviderName); + serviceFactory.Setup(factory => factory.GetDurabilityProvider()).Returns(defaultProvider); + return new DurableTaskExtension( + wrappedOptions, + new LoggerFactory(), + nameResolver, + new[] { serviceFactory.Object }, + new TestHostShutdownNotificationService(), + new DurableHttpMessageHandlerFactory(), + platformInformationService: platformInformationService); + } + // wraps the durability provider class so we can configure the CheckStatusBeforeRaiseEvent property private class DurabilityProvider : Microsoft.Azure.WebJobs.Extensions.DurableTask.DurabilityProvider { diff --git a/test/FunctionsV2/Tests/Unit/HttpApiHandlerTests.cs b/test/FunctionsV2/Tests/Unit/HttpApiHandlerTests.cs index 820cf8257..bf5edcc52 100644 --- a/test/FunctionsV2/Tests/Unit/HttpApiHandlerTests.cs +++ b/test/FunctionsV2/Tests/Unit/HttpApiHandlerTests.cs @@ -2110,6 +2110,7 @@ public async Task StartNewInstance_ExternalTarget_DoesNotValidateLocalFunction( HubName = TestConstants.TaskHub, }; var extension = TestDurableTaskExtension.CreateWithProvider(options, durabilityProvider); + extension.RegisterOrchestrator(new FunctionName(FunctionName), orchestratorInfo: null); var handler = new HttpApiHandler(extension, NullLogger.Instance); HttpResponseMessage response = await handler.HandleRequestAsync( diff --git a/test/FunctionsV2/Tests/Unit/LocalGrpcListenerTests.cs b/test/FunctionsV2/Tests/Unit/LocalGrpcListenerTests.cs index 4cae78cd6..e991c64a5 100644 --- a/test/FunctionsV2/Tests/Unit/LocalGrpcListenerTests.cs +++ b/test/FunctionsV2/Tests/Unit/LocalGrpcListenerTests.cs @@ -51,6 +51,7 @@ public enum TestGrpcListenerMode public class LocalGrpcListenerTests { private const string TaskHubMetadataKey = "Durable-TaskHub"; + private const string FunctionInvocationIdMetadataKey = "x-azure-functions-invocationid"; // Host's configured hub for the task hub attribution test. Must be a constant so it can be // referenced from [InlineData]. @@ -231,9 +232,17 @@ public async Task TestGrpcListener_DoesNotLogStartInstanceClientCancellation() public async Task TestGrpcListener_RejectsDisabledOrchestrator(bool useCaseVariantTaskHub) { const string FunctionName = "DisabledOrchestrator"; - Metadata headers = useCaseVariantTaskHub - ? new Metadata { { TaskHubMetadataKey, "disabledorchestratorstart" } } - : null; + const string InstanceId = "disabled-instance"; + const string FunctionInvocationId = "7ee6ad9a-0f87-468a-8d3c-40c51f91549a"; + var headers = new Metadata + { + { FunctionInvocationIdMetadataKey, FunctionInvocationId }, + }; + if (useCaseVariantTaskHub) + { + headers.Add(TaskHubMetadataKey, "disabledorchestratorstart"); + } + Mock durabilityProvider = CreateDurabilityProviderMock( new Mock().Object, new Mock().Object); @@ -248,7 +257,7 @@ public async Task TestGrpcListener_RejectsDisabledOrchestrator(bool useCaseVaria "DisabledOrchestratorStart", durabilityProvider.Object, async client => await client.StartInstanceAsync( - new P.CreateInstanceRequest { Name = FunctionName }, + new P.CreateInstanceRequest { Name = FunctionName, InstanceId = InstanceId }, headers).ResponseAsync, extension => extension.RegisterOrchestrator( new FunctionName(FunctionName), @@ -262,6 +271,11 @@ public async Task TestGrpcListener_RejectsDisabledOrchestrator(bool useCaseVaria It.IsAny(), It.IsAny()), Times.Never); + Assert.Contains( + this.loggerProvider.GetAllLogMessages(), + message => message.Level == LogLevel.Information && + message.FormattedMessage.Contains($"Client operation 'StartOrchestration' received for instance '{InstanceId}'") && + message.FormattedMessage.Contains(FunctionInvocationId)); } [Theory] @@ -1297,7 +1311,7 @@ private static Mock CreateDurabilityProviderMock( string connectionName = "TestConnection") { var durabilityProvider = new Mock( - "Test", + "Azure Storage", orchestrationService, orchestrationServiceClient, connectionName) diff --git a/test/e2e/Tests/Tests/DisabledOrchestrationTests.cs b/test/e2e/Tests/Tests/DisabledOrchestrationTests.cs index e272bed25..d777ad9fc 100644 --- a/test/e2e/Tests/Tests/DisabledOrchestrationTests.cs +++ b/test/e2e/Tests/Tests/DisabledOrchestrationTests.cs @@ -15,10 +15,12 @@ namespace Microsoft.Azure.Durable.Tests.DotnetIsolatedE2E; public class DisabledOrchestrationTests { private readonly FunctionAppFixture fixture; + private readonly ITestOutputHelper output; public DisabledOrchestrationTests(FunctionAppFixture fixture, ITestOutputHelper testOutputHelper) { this.fixture = fixture; + this.output = testOutputHelper; this.fixture.TestLogs.UseTestLogger(testOutputHelper); } @@ -39,6 +41,105 @@ public async Task ActiveOrchestration_StartsWhenDisabledFunctionsAreRegistered() Assert.Contains("Hello Tokyo!", details.Output); } + [Fact] + [Trait("PowerShell", "Skip")] // DisabledOrchestration is an actual disabled fixture in BasicDotNetIsolated only. + [Trait("Python", "Skip")] // DisabledOrchestration is an actual disabled fixture in BasicDotNetIsolated only. + [Trait("Node", "Skip")] // DisabledOrchestration is an actual disabled fixture in BasicDotNetIsolated only. + [Trait("Java", "Skip")] // DisabledOrchestration is an actual disabled fixture in BasicDotNetIsolated only. + public async Task DisabledOrchestration_HttpStartIsRejectedWithoutCreatingInstance() + { + string bootstrapInstanceId = $"bootstrap-{Guid.NewGuid():N}"; + using HttpResponseMessage bootstrapResponse = await HttpHelpers.InvokeHttpTrigger( + "StartOrchestration", + $"?orchestrationName=HelloCities&instanceId={bootstrapInstanceId}"); + Assert.Equal(HttpStatusCode.Accepted, bootstrapResponse.StatusCode); + + string bootstrapStatusUri = await DurableHelpers.ParseStatusQueryGetUriAsync(bootstrapResponse); + Assert.False(string.IsNullOrEmpty(bootstrapStatusUri)); + + string disabledInstanceId = $"disabled-{Guid.NewGuid():N}"; + Uri disabledStartUri = CreateManagementUri( + bootstrapStatusUri, + $"/orchestrators/DisabledOrchestration/{disabledInstanceId}"); + Uri disabledStatusUri = CreateManagementUri( + bootstrapStatusUri, + $"/instances/{disabledInstanceId}"); + + using var client = new HttpClient(); + using HttpResponseMessage startResponse = await client.PostAsync(disabledStartUri, content: null); + string startContent = await startResponse.Content.ReadAsStringAsync(); + (HttpStatusCode StatusCode, string Content) statusObservation = + await ObserveInstanceAsync(client, disabledStatusUri, startResponse.StatusCode == HttpStatusCode.Accepted); + + this.output.WriteLine($"Disabled start response: {(int)startResponse.StatusCode} {startResponse.StatusCode}; body: {startContent}"); + this.output.WriteLine($"Disabled instance lookup: {(int)statusObservation.StatusCode} {statusObservation.StatusCode}; body: {statusObservation.Content}"); + + Assert.Equal(HttpStatusCode.BadRequest, startResponse.StatusCode); + Assert.Contains("doesn't exist, is disabled, or is not an orchestrator function", startContent); + Assert.Equal(HttpStatusCode.NotFound, statusObservation.StatusCode); + } + + [Fact] + [Trait("PowerShell", "Skip")] // DisabledOrchestration is an actual disabled fixture in BasicDotNetIsolated only. + [Trait("Python", "Skip")] // DisabledOrchestration is an actual disabled fixture in BasicDotNetIsolated only. + [Trait("Node", "Skip")] // DisabledOrchestration is an actual disabled fixture in BasicDotNetIsolated only. + [Trait("Java", "Skip")] // DisabledOrchestration is an actual disabled fixture in BasicDotNetIsolated only. + public async Task DisabledOrchestration_DotNetIsolatedClientRejectsWithoutCreatingInstance() + { + string controlInstanceId = GetConfiguredInstanceId( + "DURABLE_E2E_CONTROL_INSTANCE_ID", + "control"); + using HttpResponseMessage controlStartResponse = await HttpHelpers.InvokeHttpTrigger( + "StartOrchestration", + $"?orchestrationName=HelloCities&instanceId={controlInstanceId}"); + string controlStartContent = await controlStartResponse.Content.ReadAsStringAsync(); + Assert.Equal(HttpStatusCode.Accepted, controlStartResponse.StatusCode); + + string controlStatusUri = await DurableHelpers.ParseStatusQueryGetUriAsync(controlStartResponse); + Assert.False(string.IsNullOrEmpty(controlStatusUri)); + await DurableHelpers.WaitForOrchestrationStateAsync(controlStatusUri, "Completed", 30); + + using var client = new HttpClient(); + using HttpResponseMessage controlStatusResponse = await client.GetAsync(controlStatusUri); + string controlStatusContent = await controlStatusResponse.Content.ReadAsStringAsync(); + this.output.WriteLine($"Enabled control start: {(int)controlStartResponse.StatusCode} {controlStartResponse.StatusCode}; body: {controlStartContent}"); + this.output.WriteLine($"Enabled control lookup: {(int)controlStatusResponse.StatusCode} {controlStatusResponse.StatusCode}; body: {controlStatusContent}"); + Assert.Equal(HttpStatusCode.OK, controlStatusResponse.StatusCode); + Assert.Contains("\"runtimeStatus\":\"Completed\"", controlStatusContent); + + string disabledInstanceId = GetConfiguredInstanceId( + "DURABLE_E2E_DISABLED_INSTANCE_ID", + "disabled"); + using HttpResponseMessage disabledStartResponse = await HttpHelpers.InvokeHttpTrigger( + "StartOrchestration", + $"?orchestrationName=DisabledOrchestration&instanceId={disabledInstanceId}"); + string disabledStartContent = await disabledStartResponse.Content.ReadAsStringAsync(); + Uri disabledStatusUri = CreateManagementUri( + controlStatusUri, + $"/instances/{disabledInstanceId}"); + (HttpStatusCode StatusCode, string Content) disabledStatusObservation = await ObserveInstanceAsync( + client, + disabledStatusUri, + disabledStartResponse.StatusCode == HttpStatusCode.Accepted); + + this.output.WriteLine($"Disabled isolated-client start: {(int)disabledStartResponse.StatusCode} {disabledStartResponse.StatusCode}; body: {disabledStartContent}"); + this.output.WriteLine($"Disabled isolated-client lookup: {(int)disabledStatusObservation.StatusCode} {disabledStatusObservation.StatusCode}; body: {disabledStatusObservation.Content}"); + + Assert.Equal(HttpStatusCode.InternalServerError, disabledStartResponse.StatusCode); + Assert.Equal(HttpStatusCode.NotFound, disabledStatusObservation.StatusCode); + await this.fixture.TestLogs.AssertLogExistsAsync( + log => log.Contains( + $"System.ArgumentException: Invalid argument for start instance request for instance ID {disabledInstanceId}", + StringComparison.Ordinal) && + log.Contains("DisabledOrchestration", StringComparison.Ordinal), + "Expected the .NET isolated DurableTaskClient to reject DisabledOrchestration with ArgumentException."); + await this.fixture.TestLogs.AssertLogExistsAsync( + log => log.Contains( + "GrpcDurableTaskClient.ScheduleNewOrchestrationInstanceAsync", + StringComparison.Ordinal), + "Expected the disabled start failure to originate from the gRPC DurableTaskClient."); + } + // Reproduces https://github.com/Azure/azure-functions-durable-extension/issues/3471: an // orchestration that schedules a disabled-but-still-deployed activity must fail deterministically // instead of poison-looping forever. Before the fix the activity dispatch threw during shim @@ -104,4 +205,42 @@ public async Task Orchestration_CallingDisabledEntity_FailsGracefully() Assert.Equal("Failed", details.RuntimeStatus); Assert.Contains("DisabledEntity", details.Output); } + + private static string GetConfiguredInstanceId(string settingName, string prefix) + { + return Environment.GetEnvironmentVariable(settingName) ?? $"{prefix}-{Guid.NewGuid():N}"; + } + + private static Uri CreateManagementUri(string statusQueryGetUri, string relativeOperationPath) + { + var statusUri = new Uri(statusQueryGetUri); + const string InstancesSegment = "/instances/"; + int instancesIndex = statusUri.AbsolutePath.LastIndexOf(InstancesSegment, StringComparison.OrdinalIgnoreCase); + Assert.True(instancesIndex >= 0, $"Unexpected Durable status URI: {statusQueryGetUri}"); + + var builder = new UriBuilder(statusUri) + { + Path = statusUri.AbsolutePath[..instancesIndex] + relativeOperationPath, + }; + return builder.Uri; + } + + private static async Task<(HttpStatusCode StatusCode, string Content)> ObserveInstanceAsync( + HttpClient client, + Uri statusUri, + bool waitForExistence) + { + DateTime deadline = DateTime.UtcNow.AddSeconds(10); + while (true) + { + using HttpResponseMessage response = await client.GetAsync(statusUri); + string content = await response.Content.ReadAsStringAsync(); + if (!waitForExistence || response.StatusCode != HttpStatusCode.NotFound || DateTime.UtcNow >= deadline) + { + return (response.StatusCode, content); + } + + await Task.Delay(200); + } + } } From 868499cc40e0ca26299815dfb845777753880451 Mon Sep 17 00:00:00 2001 From: wangbill Date: Fri, 14 Aug 2026 09:41:19 -0700 Subject: [PATCH 08/13] Revert "Fix disabled orchestrator start validation" This reverts commit a45586500082b443ce8c6681d1f2d73ee2bdae04. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> Copilot-Session: 7cf4a7ba-c821-42dd-ba14-0333dddc5356 --- .../ContextImplementations/DurableClient.cs | 14 +- .../IDurableOrchestrationClient.cs | 3 - .../DurabilityProvider.cs | 4 +- .../TaskHubGrpcServer.cs | 18 ++- .../Tests/Unit/DurableClientBaseTests.cs | 127 ++-------------- .../Tests/Unit/HttpApiHandlerTests.cs | 1 - .../Tests/Unit/LocalGrpcListenerTests.cs | 24 +-- .../Tests/Tests/DisabledOrchestrationTests.cs | 139 ------------------ 8 files changed, 26 insertions(+), 304 deletions(-) diff --git a/src/WebJobs.Extensions.DurableTask/ContextImplementations/DurableClient.cs b/src/WebJobs.Extensions.DurableTask/ContextImplementations/DurableClient.cs index dd9316c2c..cc00e8be7 100644 --- a/src/WebJobs.Extensions.DurableTask/ContextImplementations/DurableClient.cs +++ b/src/WebJobs.Extensions.DurableTask/ContextImplementations/DurableClient.cs @@ -30,8 +30,6 @@ internal class DurableClient : IDurableClient, #pragma warning restore 618 { private const int MaxInstanceIdLength = 256; - private const string AzureStorageProviderName = "Azure Storage"; - private const string AzureManagedProviderName = "azureManaged"; private static readonly JValue NullJValue = JValue.CreateNull(); private static readonly OrchestrationRuntimeStatus[] RunningStatus @@ -372,17 +370,7 @@ internal bool ReferencesCurrentApp() private bool TaskHubMatchesCurrentApp(DurableClient client) { var taskHubName = this.durableTaskOptions.HubName; - StringComparison comparison = UsesCaseInsensitiveTaskHubNames(this.config?.DefaultDurabilityProvider) - ? StringComparison.OrdinalIgnoreCase - : StringComparison.Ordinal; - return string.Equals(client.TaskHubName, taskHubName, comparison); - } - - private static bool UsesCaseInsensitiveTaskHubNames(DurabilityProvider provider) - { - return provider != null && - (string.Equals(provider.Name, AzureStorageProviderName, StringComparison.OrdinalIgnoreCase) || - string.Equals(provider.Name, AzureManagedProviderName, StringComparison.OrdinalIgnoreCase)); + return string.Equals(client.TaskHubName, taskHubName, StringComparison.OrdinalIgnoreCase); } private bool ConnectionNameMatchesCurrentApp(DurableClient client) diff --git a/src/WebJobs.Extensions.DurableTask/ContextInterfaces/IDurableOrchestrationClient.cs b/src/WebJobs.Extensions.DurableTask/ContextInterfaces/IDurableOrchestrationClient.cs index 16a53a6cb..8a89e9861 100644 --- a/src/WebJobs.Extensions.DurableTask/ContextInterfaces/IDurableOrchestrationClient.cs +++ b/src/WebJobs.Extensions.DurableTask/ContextInterfaces/IDurableOrchestrationClient.cs @@ -349,9 +349,6 @@ Task StartNewAsync( /// reuse the old instanceId. Defaults to true. /// A task that completes when the orchestration is started. The task contains the instance id of the started /// orchestration instance. - /// - /// The orchestrator function for the specified instance is disabled. - /// Task RestartAsync(string instanceId, bool restartWithNewInstanceId = true); /// diff --git a/src/WebJobs.Extensions.DurableTask/DurabilityProvider.cs b/src/WebJobs.Extensions.DurableTask/DurabilityProvider.cs index ca41355da..5d27d59d8 100644 --- a/src/WebJobs.Extensions.DurableTask/DurabilityProvider.cs +++ b/src/WebJobs.Extensions.DurableTask/DurabilityProvider.cs @@ -66,8 +66,6 @@ public DurabilityProvider(string storageProviderName, IOrchestrationService serv /// public virtual string ConnectionName => this.connectionName; - internal string Name => this.name; - /// /// Specifies whether the durability provider supports Durable Entities. /// @@ -615,7 +613,7 @@ public virtual bool ValidateDelayTime(TimeSpan timespan, out string errorMessage /// A boolean indicating whether the connection names match. internal virtual bool ConnectionNameMatches(DurabilityProvider durabilityProvider) { - return string.Equals(this.ConnectionName, durabilityProvider.ConnectionName, StringComparison.OrdinalIgnoreCase); + return this.ConnectionName.Equals(durabilityProvider.ConnectionName); } /// diff --git a/src/WebJobs.Extensions.DurableTask/TaskHubGrpcServer.cs b/src/WebJobs.Extensions.DurableTask/TaskHubGrpcServer.cs index 04f4368fc..9061e481a 100644 --- a/src/WebJobs.Extensions.DurableTask/TaskHubGrpcServer.cs +++ b/src/WebJobs.Extensions.DurableTask/TaskHubGrpcServer.cs @@ -59,14 +59,6 @@ public override Task Hello(Empty request, ServerCallContext context) { try { - var instance = new OrchestrationInstance - { - InstanceId = string.IsNullOrEmpty(request.InstanceId) ? Guid.NewGuid().ToString("N") : request.InstanceId, - ExecutionId = Guid.NewGuid().ToString(), - }; - - this.LogClientOperationReceived(context, "StartOrchestration", instance.InstanceId); - if (this.GetClient(context) is DurableClient durableClient && durableClient.ReferencesCurrentApp()) { this.extension.ThrowIfOrchestratorFunctionIsDisabled(request.Name); @@ -88,6 +80,16 @@ public override Task Hello(Empty request, ServerCallContext context) .Union(this.extension.Options.OverridableExistingInstanceStates.ToDedupeStatuses()) .ToArray(); + // Create the orchestration instance + var instance = new OrchestrationInstance + { + InstanceId = string.IsNullOrEmpty(request.InstanceId) ? Guid.NewGuid().ToString("N") : request.InstanceId, + ExecutionId = Guid.NewGuid().ToString(), + }; + + // Log correlation information for client operations + this.LogClientOperationReceived(context, "StartOrchestration", instance.InstanceId); + // Create the ExecutionStartedEvent ExecutionStartedEvent executionStartedEvent = new ExecutionStartedEvent(-1, request.Input) { diff --git a/test/FunctionsV2/Tests/Unit/DurableClientBaseTests.cs b/test/FunctionsV2/Tests/Unit/DurableClientBaseTests.cs index 2fb94d6ad..69beacfe4 100644 --- a/test/FunctionsV2/Tests/Unit/DurableClientBaseTests.cs +++ b/test/FunctionsV2/Tests/Unit/DurableClientBaseTests.cs @@ -81,31 +81,21 @@ public async Task StartNewAsync_MissingOrchestrator_ThrowsException() } [Theory] - [InlineData("Azure Storage", null, true)] - [InlineData("Azure Storage", "durabletaskhub", true)] - [InlineData("azureManaged", "durabletaskhub", true)] - [InlineData("mssql", "durabletaskhub", false)] - [InlineData("mssql", "DurableTaskHub", true)] - [InlineData("Netherite", "durabletaskhub", false)] - [InlineData("Netherite", "DurableTaskHub", true)] - [InlineData("custom", "durabletaskhub", false)] - [InlineData("custom", "DurableTaskHub", true)] + [InlineData(null)] + [InlineData("durabletaskhub")] [Trait("Category", PlatformSpecificHelpers.TestCategory)] - public async Task StartNewAsync_DisabledOrchestrator_UsesDefaultProviderTaskHubCaseSensitivity( - string defaultProviderName, - string taskHub, - bool rejectStart) + public async Task StartNewAsync_DisabledOrchestrator_ThrowsException(string taskHub) { var orchestrationServiceClientMock = new Mock(); orchestrationServiceClientMock .Setup(x => x.CreateTaskOrchestrationAsync(It.IsAny(), It.IsAny())) .Returns(Task.CompletedTask); var storageProvider = new DurabilityProvider( - "clientProvider", + "test", new Mock().Object, orchestrationServiceClientMock.Object, TestConstants.ConnectionName); - var durableExtension = GetDurableTaskConfig(defaultProviderName); + var durableExtension = GetDurableTaskConfig(); durableExtension.RegisterOrchestrator(new FunctionName("DisabledOrchestrator"), orchestratorInfo: null); var durableClient = (IDurableOrchestrationClient)new DurableClient( storageProvider, @@ -113,20 +103,13 @@ public async Task StartNewAsync_DisabledOrchestrator_UsesDefaultProviderTaskHubC durableExtension.HttpApiHandler, new DurableClientAttribute { TaskHub = taskHub }); - if (rejectStart) - { - ArgumentException exception = await Assert.ThrowsAnyAsync( - () => durableClient.StartNewAsync("DisabledOrchestrator")); - Assert.Contains("doesn't exist, is disabled, or is not an orchestrator function", exception.Message); - } - else - { - await durableClient.StartNewAsync("DisabledOrchestrator"); - } + ArgumentException exception = await Assert.ThrowsAnyAsync( + () => durableClient.StartNewAsync("DisabledOrchestrator")); + Assert.Contains("doesn't exist, is disabled, or is not an orchestrator function", exception.Message); orchestrationServiceClientMock.Verify( x => x.CreateTaskOrchestrationAsync(It.IsAny(), It.IsAny()), - rejectStart ? Times.Never() : Times.Once()); + Times.Never()); } [Theory] @@ -238,69 +221,6 @@ public async Task SignalEntity_InvalidEntityKey_ThrowsException(string entityKey await Assert.ThrowsAnyAsync(async () => await durableClient.SignalEntityAsync(entityId, "test")); } - [Theory] - [InlineData(null, TestConstants.ConnectionName)] - [InlineData("durabletaskhub", TestConstants.ConnectionName)] - [InlineData(null, "storage")] - [Trait("Category", PlatformSpecificHelpers.TestCategory)] - public async Task SignalEntityAsync_CurrentAppMissingEntity_ThrowsException( - string taskHub, - string connectionName) - { - var orchestrationServiceClientMock = new Mock(); - orchestrationServiceClientMock - .Setup(client => client.SendTaskOrchestrationMessageAsync(It.IsAny())) - .Returns(Task.CompletedTask); - var storageProvider = new DurabilityProvider( - "test", - new Mock().Object, - orchestrationServiceClientMock.Object, - connectionName); - var durableExtension = GetDurableTaskConfig(); - var durableClient = (IDurableEntityClient)new DurableClient( - storageProvider, - durableExtension, - durableExtension.HttpApiHandler, - new DurableClientAttribute { TaskHub = taskHub }); - - await Assert.ThrowsAnyAsync( - () => durableClient.SignalEntityAsync(new EntityId("MissingEntity", "key"), "operation")); - orchestrationServiceClientMock.Verify( - client => client.SendTaskOrchestrationMessageAsync(It.IsAny()), - Times.Never); - } - - [Theory] - [InlineData("RemoteHub", TestConstants.ConnectionName)] - [InlineData(null, TestConstants.CustomConnectionName)] - [Trait("Category", PlatformSpecificHelpers.TestCategory)] - public async Task SignalEntityAsync_ExternalTarget_DoesNotValidateLocalEntity( - string taskHub, - string connectionName) - { - var orchestrationServiceClientMock = new Mock(); - orchestrationServiceClientMock - .Setup(client => client.SendTaskOrchestrationMessageAsync(It.IsAny())) - .Returns(Task.CompletedTask); - var storageProvider = new DurabilityProvider( - "test", - new Mock().Object, - orchestrationServiceClientMock.Object, - connectionName); - var durableExtension = GetDurableTaskConfig(); - var durableClient = (IDurableEntityClient)new DurableClient( - storageProvider, - durableExtension, - durableExtension.HttpApiHandler, - new DurableClientAttribute { TaskHub = taskHub }); - - await durableClient.SignalEntityAsync(new EntityId("RemoteEntity", "key"), "operation"); - - orchestrationServiceClientMock.Verify( - client => client.SendTaskOrchestrationMessageAsync(It.IsAny()), - Times.Once); - } - [Theory] [Trait("Category", PlatformSpecificHelpers.TestCategory)] [InlineData(false)] @@ -664,35 +584,6 @@ private static DurableTaskExtension GetDurableTaskConfig() platformInformationService: platformInformationService); } - private static DurableTaskExtension GetDurableTaskConfig(string defaultProviderName) - { - var options = new DurableTaskOptions - { - HubName = "DurableTaskHub", - WebhookUriProviderOverride = () => new Uri("https://sampleurl.net"), - }; - options.StorageProvider["type"] = defaultProviderName; - var wrappedOptions = new OptionsWrapper(options); - var nameResolver = TestHelpers.GetTestNameResolver(); - var platformInformationService = TestHelpers.GetMockPlatformInformationService(); - var defaultProvider = new DurabilityProvider( - defaultProviderName, - new Mock().Object, - new Mock().Object, - TestConstants.ConnectionName); - var serviceFactory = new Mock(); - serviceFactory.SetupGet(factory => factory.Name).Returns(defaultProviderName); - serviceFactory.Setup(factory => factory.GetDurabilityProvider()).Returns(defaultProvider); - return new DurableTaskExtension( - wrappedOptions, - new LoggerFactory(), - nameResolver, - new[] { serviceFactory.Object }, - new TestHostShutdownNotificationService(), - new DurableHttpMessageHandlerFactory(), - platformInformationService: platformInformationService); - } - // wraps the durability provider class so we can configure the CheckStatusBeforeRaiseEvent property private class DurabilityProvider : Microsoft.Azure.WebJobs.Extensions.DurableTask.DurabilityProvider { diff --git a/test/FunctionsV2/Tests/Unit/HttpApiHandlerTests.cs b/test/FunctionsV2/Tests/Unit/HttpApiHandlerTests.cs index bf5edcc52..820cf8257 100644 --- a/test/FunctionsV2/Tests/Unit/HttpApiHandlerTests.cs +++ b/test/FunctionsV2/Tests/Unit/HttpApiHandlerTests.cs @@ -2110,7 +2110,6 @@ public async Task StartNewInstance_ExternalTarget_DoesNotValidateLocalFunction( HubName = TestConstants.TaskHub, }; var extension = TestDurableTaskExtension.CreateWithProvider(options, durabilityProvider); - extension.RegisterOrchestrator(new FunctionName(FunctionName), orchestratorInfo: null); var handler = new HttpApiHandler(extension, NullLogger.Instance); HttpResponseMessage response = await handler.HandleRequestAsync( diff --git a/test/FunctionsV2/Tests/Unit/LocalGrpcListenerTests.cs b/test/FunctionsV2/Tests/Unit/LocalGrpcListenerTests.cs index e991c64a5..4cae78cd6 100644 --- a/test/FunctionsV2/Tests/Unit/LocalGrpcListenerTests.cs +++ b/test/FunctionsV2/Tests/Unit/LocalGrpcListenerTests.cs @@ -51,7 +51,6 @@ public enum TestGrpcListenerMode public class LocalGrpcListenerTests { private const string TaskHubMetadataKey = "Durable-TaskHub"; - private const string FunctionInvocationIdMetadataKey = "x-azure-functions-invocationid"; // Host's configured hub for the task hub attribution test. Must be a constant so it can be // referenced from [InlineData]. @@ -232,17 +231,9 @@ public async Task TestGrpcListener_DoesNotLogStartInstanceClientCancellation() public async Task TestGrpcListener_RejectsDisabledOrchestrator(bool useCaseVariantTaskHub) { const string FunctionName = "DisabledOrchestrator"; - const string InstanceId = "disabled-instance"; - const string FunctionInvocationId = "7ee6ad9a-0f87-468a-8d3c-40c51f91549a"; - var headers = new Metadata - { - { FunctionInvocationIdMetadataKey, FunctionInvocationId }, - }; - if (useCaseVariantTaskHub) - { - headers.Add(TaskHubMetadataKey, "disabledorchestratorstart"); - } - + Metadata headers = useCaseVariantTaskHub + ? new Metadata { { TaskHubMetadataKey, "disabledorchestratorstart" } } + : null; Mock durabilityProvider = CreateDurabilityProviderMock( new Mock().Object, new Mock().Object); @@ -257,7 +248,7 @@ public async Task TestGrpcListener_RejectsDisabledOrchestrator(bool useCaseVaria "DisabledOrchestratorStart", durabilityProvider.Object, async client => await client.StartInstanceAsync( - new P.CreateInstanceRequest { Name = FunctionName, InstanceId = InstanceId }, + new P.CreateInstanceRequest { Name = FunctionName }, headers).ResponseAsync, extension => extension.RegisterOrchestrator( new FunctionName(FunctionName), @@ -271,11 +262,6 @@ public async Task TestGrpcListener_RejectsDisabledOrchestrator(bool useCaseVaria It.IsAny(), It.IsAny()), Times.Never); - Assert.Contains( - this.loggerProvider.GetAllLogMessages(), - message => message.Level == LogLevel.Information && - message.FormattedMessage.Contains($"Client operation 'StartOrchestration' received for instance '{InstanceId}'") && - message.FormattedMessage.Contains(FunctionInvocationId)); } [Theory] @@ -1311,7 +1297,7 @@ private static Mock CreateDurabilityProviderMock( string connectionName = "TestConnection") { var durabilityProvider = new Mock( - "Azure Storage", + "Test", orchestrationService, orchestrationServiceClient, connectionName) diff --git a/test/e2e/Tests/Tests/DisabledOrchestrationTests.cs b/test/e2e/Tests/Tests/DisabledOrchestrationTests.cs index d777ad9fc..e272bed25 100644 --- a/test/e2e/Tests/Tests/DisabledOrchestrationTests.cs +++ b/test/e2e/Tests/Tests/DisabledOrchestrationTests.cs @@ -15,12 +15,10 @@ namespace Microsoft.Azure.Durable.Tests.DotnetIsolatedE2E; public class DisabledOrchestrationTests { private readonly FunctionAppFixture fixture; - private readonly ITestOutputHelper output; public DisabledOrchestrationTests(FunctionAppFixture fixture, ITestOutputHelper testOutputHelper) { this.fixture = fixture; - this.output = testOutputHelper; this.fixture.TestLogs.UseTestLogger(testOutputHelper); } @@ -41,105 +39,6 @@ public async Task ActiveOrchestration_StartsWhenDisabledFunctionsAreRegistered() Assert.Contains("Hello Tokyo!", details.Output); } - [Fact] - [Trait("PowerShell", "Skip")] // DisabledOrchestration is an actual disabled fixture in BasicDotNetIsolated only. - [Trait("Python", "Skip")] // DisabledOrchestration is an actual disabled fixture in BasicDotNetIsolated only. - [Trait("Node", "Skip")] // DisabledOrchestration is an actual disabled fixture in BasicDotNetIsolated only. - [Trait("Java", "Skip")] // DisabledOrchestration is an actual disabled fixture in BasicDotNetIsolated only. - public async Task DisabledOrchestration_HttpStartIsRejectedWithoutCreatingInstance() - { - string bootstrapInstanceId = $"bootstrap-{Guid.NewGuid():N}"; - using HttpResponseMessage bootstrapResponse = await HttpHelpers.InvokeHttpTrigger( - "StartOrchestration", - $"?orchestrationName=HelloCities&instanceId={bootstrapInstanceId}"); - Assert.Equal(HttpStatusCode.Accepted, bootstrapResponse.StatusCode); - - string bootstrapStatusUri = await DurableHelpers.ParseStatusQueryGetUriAsync(bootstrapResponse); - Assert.False(string.IsNullOrEmpty(bootstrapStatusUri)); - - string disabledInstanceId = $"disabled-{Guid.NewGuid():N}"; - Uri disabledStartUri = CreateManagementUri( - bootstrapStatusUri, - $"/orchestrators/DisabledOrchestration/{disabledInstanceId}"); - Uri disabledStatusUri = CreateManagementUri( - bootstrapStatusUri, - $"/instances/{disabledInstanceId}"); - - using var client = new HttpClient(); - using HttpResponseMessage startResponse = await client.PostAsync(disabledStartUri, content: null); - string startContent = await startResponse.Content.ReadAsStringAsync(); - (HttpStatusCode StatusCode, string Content) statusObservation = - await ObserveInstanceAsync(client, disabledStatusUri, startResponse.StatusCode == HttpStatusCode.Accepted); - - this.output.WriteLine($"Disabled start response: {(int)startResponse.StatusCode} {startResponse.StatusCode}; body: {startContent}"); - this.output.WriteLine($"Disabled instance lookup: {(int)statusObservation.StatusCode} {statusObservation.StatusCode}; body: {statusObservation.Content}"); - - Assert.Equal(HttpStatusCode.BadRequest, startResponse.StatusCode); - Assert.Contains("doesn't exist, is disabled, or is not an orchestrator function", startContent); - Assert.Equal(HttpStatusCode.NotFound, statusObservation.StatusCode); - } - - [Fact] - [Trait("PowerShell", "Skip")] // DisabledOrchestration is an actual disabled fixture in BasicDotNetIsolated only. - [Trait("Python", "Skip")] // DisabledOrchestration is an actual disabled fixture in BasicDotNetIsolated only. - [Trait("Node", "Skip")] // DisabledOrchestration is an actual disabled fixture in BasicDotNetIsolated only. - [Trait("Java", "Skip")] // DisabledOrchestration is an actual disabled fixture in BasicDotNetIsolated only. - public async Task DisabledOrchestration_DotNetIsolatedClientRejectsWithoutCreatingInstance() - { - string controlInstanceId = GetConfiguredInstanceId( - "DURABLE_E2E_CONTROL_INSTANCE_ID", - "control"); - using HttpResponseMessage controlStartResponse = await HttpHelpers.InvokeHttpTrigger( - "StartOrchestration", - $"?orchestrationName=HelloCities&instanceId={controlInstanceId}"); - string controlStartContent = await controlStartResponse.Content.ReadAsStringAsync(); - Assert.Equal(HttpStatusCode.Accepted, controlStartResponse.StatusCode); - - string controlStatusUri = await DurableHelpers.ParseStatusQueryGetUriAsync(controlStartResponse); - Assert.False(string.IsNullOrEmpty(controlStatusUri)); - await DurableHelpers.WaitForOrchestrationStateAsync(controlStatusUri, "Completed", 30); - - using var client = new HttpClient(); - using HttpResponseMessage controlStatusResponse = await client.GetAsync(controlStatusUri); - string controlStatusContent = await controlStatusResponse.Content.ReadAsStringAsync(); - this.output.WriteLine($"Enabled control start: {(int)controlStartResponse.StatusCode} {controlStartResponse.StatusCode}; body: {controlStartContent}"); - this.output.WriteLine($"Enabled control lookup: {(int)controlStatusResponse.StatusCode} {controlStatusResponse.StatusCode}; body: {controlStatusContent}"); - Assert.Equal(HttpStatusCode.OK, controlStatusResponse.StatusCode); - Assert.Contains("\"runtimeStatus\":\"Completed\"", controlStatusContent); - - string disabledInstanceId = GetConfiguredInstanceId( - "DURABLE_E2E_DISABLED_INSTANCE_ID", - "disabled"); - using HttpResponseMessage disabledStartResponse = await HttpHelpers.InvokeHttpTrigger( - "StartOrchestration", - $"?orchestrationName=DisabledOrchestration&instanceId={disabledInstanceId}"); - string disabledStartContent = await disabledStartResponse.Content.ReadAsStringAsync(); - Uri disabledStatusUri = CreateManagementUri( - controlStatusUri, - $"/instances/{disabledInstanceId}"); - (HttpStatusCode StatusCode, string Content) disabledStatusObservation = await ObserveInstanceAsync( - client, - disabledStatusUri, - disabledStartResponse.StatusCode == HttpStatusCode.Accepted); - - this.output.WriteLine($"Disabled isolated-client start: {(int)disabledStartResponse.StatusCode} {disabledStartResponse.StatusCode}; body: {disabledStartContent}"); - this.output.WriteLine($"Disabled isolated-client lookup: {(int)disabledStatusObservation.StatusCode} {disabledStatusObservation.StatusCode}; body: {disabledStatusObservation.Content}"); - - Assert.Equal(HttpStatusCode.InternalServerError, disabledStartResponse.StatusCode); - Assert.Equal(HttpStatusCode.NotFound, disabledStatusObservation.StatusCode); - await this.fixture.TestLogs.AssertLogExistsAsync( - log => log.Contains( - $"System.ArgumentException: Invalid argument for start instance request for instance ID {disabledInstanceId}", - StringComparison.Ordinal) && - log.Contains("DisabledOrchestration", StringComparison.Ordinal), - "Expected the .NET isolated DurableTaskClient to reject DisabledOrchestration with ArgumentException."); - await this.fixture.TestLogs.AssertLogExistsAsync( - log => log.Contains( - "GrpcDurableTaskClient.ScheduleNewOrchestrationInstanceAsync", - StringComparison.Ordinal), - "Expected the disabled start failure to originate from the gRPC DurableTaskClient."); - } - // Reproduces https://github.com/Azure/azure-functions-durable-extension/issues/3471: an // orchestration that schedules a disabled-but-still-deployed activity must fail deterministically // instead of poison-looping forever. Before the fix the activity dispatch threw during shim @@ -205,42 +104,4 @@ public async Task Orchestration_CallingDisabledEntity_FailsGracefully() Assert.Equal("Failed", details.RuntimeStatus); Assert.Contains("DisabledEntity", details.Output); } - - private static string GetConfiguredInstanceId(string settingName, string prefix) - { - return Environment.GetEnvironmentVariable(settingName) ?? $"{prefix}-{Guid.NewGuid():N}"; - } - - private static Uri CreateManagementUri(string statusQueryGetUri, string relativeOperationPath) - { - var statusUri = new Uri(statusQueryGetUri); - const string InstancesSegment = "/instances/"; - int instancesIndex = statusUri.AbsolutePath.LastIndexOf(InstancesSegment, StringComparison.OrdinalIgnoreCase); - Assert.True(instancesIndex >= 0, $"Unexpected Durable status URI: {statusQueryGetUri}"); - - var builder = new UriBuilder(statusUri) - { - Path = statusUri.AbsolutePath[..instancesIndex] + relativeOperationPath, - }; - return builder.Uri; - } - - private static async Task<(HttpStatusCode StatusCode, string Content)> ObserveInstanceAsync( - HttpClient client, - Uri statusUri, - bool waitForExistence) - { - DateTime deadline = DateTime.UtcNow.AddSeconds(10); - while (true) - { - using HttpResponseMessage response = await client.GetAsync(statusUri); - string content = await response.Content.ReadAsStringAsync(); - if (!waitForExistence || response.StatusCode != HttpStatusCode.NotFound || DateTime.UtcNow >= deadline) - { - return (response.StatusCode, content); - } - - await Task.Delay(200); - } - } } From b9bd56a6b33f8550079f350c26193391aec4adc8 Mon Sep 17 00:00:00 2001 From: wangbill Date: Fri, 14 Aug 2026 09:43:46 -0700 Subject: [PATCH 09/13] Use provider-specific task hub casing Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> Copilot-Session: 7cf4a7ba-c821-42dd-ba14-0333dddc5356 --- .../ContextImplementations/DurableClient.cs | 14 +++- .../DurabilityProvider.cs | 2 + .../Tests/Unit/DurableClientBaseTests.cs | 64 ++++++++++++++++--- .../Tests/Unit/LocalGrpcListenerTests.cs | 2 +- 4 files changed, 71 insertions(+), 11 deletions(-) diff --git a/src/WebJobs.Extensions.DurableTask/ContextImplementations/DurableClient.cs b/src/WebJobs.Extensions.DurableTask/ContextImplementations/DurableClient.cs index cc00e8be7..dd9316c2c 100644 --- a/src/WebJobs.Extensions.DurableTask/ContextImplementations/DurableClient.cs +++ b/src/WebJobs.Extensions.DurableTask/ContextImplementations/DurableClient.cs @@ -30,6 +30,8 @@ internal class DurableClient : IDurableClient, #pragma warning restore 618 { private const int MaxInstanceIdLength = 256; + private const string AzureStorageProviderName = "Azure Storage"; + private const string AzureManagedProviderName = "azureManaged"; private static readonly JValue NullJValue = JValue.CreateNull(); private static readonly OrchestrationRuntimeStatus[] RunningStatus @@ -370,7 +372,17 @@ internal bool ReferencesCurrentApp() private bool TaskHubMatchesCurrentApp(DurableClient client) { var taskHubName = this.durableTaskOptions.HubName; - return string.Equals(client.TaskHubName, taskHubName, StringComparison.OrdinalIgnoreCase); + StringComparison comparison = UsesCaseInsensitiveTaskHubNames(this.config?.DefaultDurabilityProvider) + ? StringComparison.OrdinalIgnoreCase + : StringComparison.Ordinal; + return string.Equals(client.TaskHubName, taskHubName, comparison); + } + + private static bool UsesCaseInsensitiveTaskHubNames(DurabilityProvider provider) + { + return provider != null && + (string.Equals(provider.Name, AzureStorageProviderName, StringComparison.OrdinalIgnoreCase) || + string.Equals(provider.Name, AzureManagedProviderName, StringComparison.OrdinalIgnoreCase)); } private bool ConnectionNameMatchesCurrentApp(DurableClient client) diff --git a/src/WebJobs.Extensions.DurableTask/DurabilityProvider.cs b/src/WebJobs.Extensions.DurableTask/DurabilityProvider.cs index 5d27d59d8..57f4f66ab 100644 --- a/src/WebJobs.Extensions.DurableTask/DurabilityProvider.cs +++ b/src/WebJobs.Extensions.DurableTask/DurabilityProvider.cs @@ -66,6 +66,8 @@ public DurabilityProvider(string storageProviderName, IOrchestrationService serv /// public virtual string ConnectionName => this.connectionName; + internal string Name => this.name; + /// /// Specifies whether the durability provider supports Durable Entities. /// diff --git a/test/FunctionsV2/Tests/Unit/DurableClientBaseTests.cs b/test/FunctionsV2/Tests/Unit/DurableClientBaseTests.cs index 69beacfe4..7297ce6d3 100644 --- a/test/FunctionsV2/Tests/Unit/DurableClientBaseTests.cs +++ b/test/FunctionsV2/Tests/Unit/DurableClientBaseTests.cs @@ -81,21 +81,31 @@ public async Task StartNewAsync_MissingOrchestrator_ThrowsException() } [Theory] - [InlineData(null)] - [InlineData("durabletaskhub")] + [InlineData("Azure Storage", null, true)] + [InlineData("Azure Storage", "durabletaskhub", true)] + [InlineData("azureManaged", "durabletaskhub", true)] + [InlineData("mssql", "durabletaskhub", false)] + [InlineData("mssql", "DurableTaskHub", true)] + [InlineData("Netherite", "durabletaskhub", false)] + [InlineData("Netherite", "DurableTaskHub", true)] + [InlineData("custom", "durabletaskhub", false)] + [InlineData("custom", "DurableTaskHub", true)] [Trait("Category", PlatformSpecificHelpers.TestCategory)] - public async Task StartNewAsync_DisabledOrchestrator_ThrowsException(string taskHub) + public async Task StartNewAsync_DisabledOrchestrator_UsesDefaultProviderTaskHubCaseSensitivity( + string defaultProviderName, + string taskHub, + bool rejectStart) { var orchestrationServiceClientMock = new Mock(); orchestrationServiceClientMock .Setup(x => x.CreateTaskOrchestrationAsync(It.IsAny(), It.IsAny())) .Returns(Task.CompletedTask); var storageProvider = new DurabilityProvider( - "test", + "clientProvider", new Mock().Object, orchestrationServiceClientMock.Object, TestConstants.ConnectionName); - var durableExtension = GetDurableTaskConfig(); + var durableExtension = GetDurableTaskConfig(defaultProviderName); durableExtension.RegisterOrchestrator(new FunctionName("DisabledOrchestrator"), orchestratorInfo: null); var durableClient = (IDurableOrchestrationClient)new DurableClient( storageProvider, @@ -103,13 +113,20 @@ public async Task StartNewAsync_DisabledOrchestrator_ThrowsException(string task durableExtension.HttpApiHandler, new DurableClientAttribute { TaskHub = taskHub }); - ArgumentException exception = await Assert.ThrowsAnyAsync( - () => durableClient.StartNewAsync("DisabledOrchestrator")); + if (rejectStart) + { + ArgumentException exception = await Assert.ThrowsAnyAsync( + () => durableClient.StartNewAsync("DisabledOrchestrator")); + Assert.Contains("doesn't exist, is disabled, or is not an orchestrator function", exception.Message); + } + else + { + await durableClient.StartNewAsync("DisabledOrchestrator"); + } - Assert.Contains("doesn't exist, is disabled, or is not an orchestrator function", exception.Message); orchestrationServiceClientMock.Verify( x => x.CreateTaskOrchestrationAsync(It.IsAny(), It.IsAny()), - Times.Never()); + rejectStart ? Times.Never() : Times.Once()); } [Theory] @@ -584,6 +601,35 @@ private static DurableTaskExtension GetDurableTaskConfig() platformInformationService: platformInformationService); } + private static DurableTaskExtension GetDurableTaskConfig(string defaultProviderName) + { + var options = new DurableTaskOptions + { + HubName = "DurableTaskHub", + WebhookUriProviderOverride = () => new Uri("https://sampleurl.net"), + }; + options.StorageProvider["type"] = defaultProviderName; + var wrappedOptions = new OptionsWrapper(options); + var nameResolver = TestHelpers.GetTestNameResolver(); + var platformInformationService = TestHelpers.GetMockPlatformInformationService(); + var defaultProvider = new DurabilityProvider( + defaultProviderName, + new Mock().Object, + new Mock().Object, + TestConstants.ConnectionName); + var serviceFactory = new Mock(); + serviceFactory.SetupGet(factory => factory.Name).Returns(defaultProviderName); + serviceFactory.Setup(factory => factory.GetDurabilityProvider()).Returns(defaultProvider); + return new DurableTaskExtension( + wrappedOptions, + new LoggerFactory(), + nameResolver, + new[] { serviceFactory.Object }, + new TestHostShutdownNotificationService(), + new DurableHttpMessageHandlerFactory(), + platformInformationService: platformInformationService); + } + // wraps the durability provider class so we can configure the CheckStatusBeforeRaiseEvent property private class DurabilityProvider : Microsoft.Azure.WebJobs.Extensions.DurableTask.DurabilityProvider { diff --git a/test/FunctionsV2/Tests/Unit/LocalGrpcListenerTests.cs b/test/FunctionsV2/Tests/Unit/LocalGrpcListenerTests.cs index 4cae78cd6..d93ea561c 100644 --- a/test/FunctionsV2/Tests/Unit/LocalGrpcListenerTests.cs +++ b/test/FunctionsV2/Tests/Unit/LocalGrpcListenerTests.cs @@ -1297,7 +1297,7 @@ private static Mock CreateDurabilityProviderMock( string connectionName = "TestConnection") { var durabilityProvider = new Mock( - "Test", + "Azure Storage", orchestrationService, orchestrationServiceClient, connectionName) From 32a2a3f13aba4245905de486d4b3cf88fb5119c8 Mon Sep 17 00:00:00 2001 From: wangbill Date: Fri, 14 Aug 2026 10:25:55 -0700 Subject: [PATCH 10/13] Add disabled orchestrator E2E coverage Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> Copilot-Session: 7cf4a7ba-c821-42dd-ba14-0333dddc5356 --- .../FunctionApp/TestOrchestrations.cs | 6 +++ .../Tests/E2E/StatusAndQueryTests.cs | 48 +++++++++++++++++++ 2 files changed, 54 insertions(+) diff --git a/test/FunctionsV2/FunctionApp/TestOrchestrations.cs b/test/FunctionsV2/FunctionApp/TestOrchestrations.cs index d0791895b..c6f411d3c 100644 --- a/test/FunctionsV2/FunctionApp/TestOrchestrations.cs +++ b/test/FunctionsV2/FunctionApp/TestOrchestrations.cs @@ -20,6 +20,12 @@ internal static class TestOrchestrations public static bool SayHelloWithActivityForRewindShouldFail { get; set; } = true; + [Disable] + public static string DisabledOrchestrator([OrchestrationTrigger] IDurableOrchestrationContext ctx) + { + return nameof(DisabledOrchestrator); + } + public static string SayHelloInline([OrchestrationTrigger] IDurableOrchestrationContext ctx) { string input = ctx.GetInput(); diff --git a/test/FunctionsV2/Tests/E2E/StatusAndQueryTests.cs b/test/FunctionsV2/Tests/E2E/StatusAndQueryTests.cs index 4dfcee539..17079a12f 100644 --- a/test/FunctionsV2/Tests/E2E/StatusAndQueryTests.cs +++ b/test/FunctionsV2/Tests/E2E/StatusAndQueryTests.cs @@ -57,6 +57,54 @@ public async Task StartOrchestration_OnUnregisteredOrchestrator(bool extendedSes } } + [Fact] + [Trait("Category", PlatformSpecificHelpers.TestCategory)] + public async Task DisabledOrchestrator_CaseVariantTaskHub_IsRejectedWithoutPersistingInstance() + { + const string InstanceId = "disabled-case-variant-instance"; + string taskHubName = TestHelpers.GetTaskHubNameFromTestName( + nameof(this.DisabledOrchestrator_CaseVariantTaskHub_IsRejectedWithoutPersistingInstance), + enableExtendedSessions: false).ToLowerInvariant(); + string hostTaskHubName = char.ToUpperInvariant(taskHubName[0]) + taskHubName.Substring(1); + var nameResolver = new SimpleNameResolver( + new Dictionary + { + { "TestTaskHub", taskHubName }, + }); + + using (ITestHost host = TestHelpers.GetJobHost( + this.loggerProvider, + nameof(this.DisabledOrchestrator_CaseVariantTaskHub_IsRejectedWithoutPersistingInstance), + enableExtendedSessions: false, + nameResolver: nameResolver, + storageProviderType: TestHelpers.AzureStorageProviderType, + exactTaskHubName: hostTaskHubName)) + { + await host.StartAsync(); + + Exception exception = await Record.ExceptionAsync( + () => host.StartOrchestratorAsync( + nameof(TestOrchestrations.DisabledOrchestrator), + input: null, + this.output, + instanceId: InstanceId, + useTaskHubFromAppSettings: true)); + + IDurableOrchestrationClient defaultClient = + await host.GetOrchestrationClientBindingTest(this.output); + Assert.Null(await defaultClient.GetStatusAsync(InstanceId)); + + FunctionInvocationException invocationException = + Assert.IsType(exception); + Assert.NotNull(invocationException.InnerException); + Assert.Contains( + "doesn't exist, is disabled, or is not an orchestrator function", + invocationException.InnerException.ToString()); + + await host.StopAsync(); + } + } + /// /// End-to-end test which creates an external client that calls a non-existent orchestrator function. /// From 990df360bc1efb15188e5f581677af7302927adb Mon Sep 17 00:00:00 2001 From: wangbill Date: Tue, 18 Aug 2026 11:35:55 -0400 Subject: [PATCH 11/13] Cover cross-connection client targeting Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> Copilot-Session: 7cf4a7ba-c821-42dd-ba14-0333dddc5356 --- .../Tests/Unit/DurableClientBaseTests.cs | 64 +++++++++++++++++++ 1 file changed, 64 insertions(+) diff --git a/test/FunctionsV2/Tests/Unit/DurableClientBaseTests.cs b/test/FunctionsV2/Tests/Unit/DurableClientBaseTests.cs index 7297ce6d3..1124dcbdc 100644 --- a/test/FunctionsV2/Tests/Unit/DurableClientBaseTests.cs +++ b/test/FunctionsV2/Tests/Unit/DurableClientBaseTests.cs @@ -80,6 +80,20 @@ public async Task StartNewAsync_MissingOrchestrator_ThrowsException() Times.Never()); } + [Fact] + [Trait("Category", PlatformSpecificHelpers.TestCategory)] + public async Task StartNewAsync_DifferentConnection_DoesNotValidateLocalOrchestrator() + { + (DurableClient durableClient, Mock serviceClient) = + CreateCrossConnectionClient(); + + await ((IDurableOrchestrationClient)durableClient).StartNewAsync("RemoteOrchestrator"); + + serviceClient.Verify( + x => x.CreateTaskOrchestrationAsync(It.IsAny(), It.IsAny()), + Times.Once()); + } + [Theory] [InlineData("Azure Storage", null, true)] [InlineData("Azure Storage", "durabletaskhub", true)] @@ -238,6 +252,23 @@ public async Task SignalEntity_InvalidEntityKey_ThrowsException(string entityKey await Assert.ThrowsAnyAsync(async () => await durableClient.SignalEntityAsync(entityId, "test")); } + [Fact] + [Trait("Category", PlatformSpecificHelpers.TestCategory)] + public async Task SignalEntityAsync_DifferentConnection_DoesNotValidateLocalEntity() + { + (DurableClient durableClient, Mock serviceClient) = + CreateCrossConnectionClient(); + + await ((IDurableEntityClient)durableClient).SignalEntityAsync( + new EntityId("RemoteEntity", "entity-key"), + "operation", + new { Value = 1 }); + + serviceClient.Verify( + x => x.SendTaskOrchestrationMessageAsync(It.IsAny()), + Times.Once()); + } + [Theory] [Trait("Category", PlatformSpecificHelpers.TestCategory)] [InlineData(false)] @@ -487,6 +518,39 @@ private IDurableOrchestrationClient GetDurableClient(IOrchestrationServiceClient return durableOrchestrationClient; } + private static (DurableClient Client, Mock ServiceClient) CreateCrossConnectionClient() + { + const string TargetConnectionName = "TargetStorage"; + var serviceClient = new Mock(); + serviceClient + .Setup(x => x.CreateTaskOrchestrationAsync(It.IsAny(), It.IsAny())) + .Returns(Task.CompletedTask); + serviceClient + .Setup(x => x.SendTaskOrchestrationMessageAsync(It.IsAny())) + .Returns(Task.CompletedTask); + var storageProvider = new DurabilityProvider( + "clientProvider", + new Mock().Object, + serviceClient.Object, + TargetConnectionName); + var durableExtension = GetDurableTaskConfig(); + Assert.NotEqual( + durableExtension.DefaultDurabilityProvider.ConnectionName, + storageProvider.ConnectionName); + var attribute = new DurableClientAttribute + { + TaskHub = durableExtension.Options.HubName, + ConnectionName = TargetConnectionName, + ExternalClient = false, + }; + var client = new DurableClient( + storageProvider, + durableExtension, + durableExtension.HttpApiHandler, + attribute); + return (client, serviceClient); + } + [Fact] [Trait("Category", PlatformSpecificHelpers.TestCategory)] public async Task HttpRequest_HttpRequestMessage_ClientMethods_Identical() From 5f97425efb9995d65761277f7830d8f9c5951bfd Mon Sep 17 00:00:00 2001 From: wangbill Date: Wed, 19 Aug 2026 09:43:39 -0400 Subject: [PATCH 12/13] Scope disabled orchestrator validation Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> Copilot-Session: e84c5737-8808-4d03-901a-49afc08fbcf0 --- .../ContextImplementations/DurableClient.cs | 37 ++++-- .../HttpApiHandler.cs | 5 +- .../TaskHubGrpcServer.cs | 4 +- .../Tests/Unit/DurableClientBaseTests.cs | 118 +++++++++++++++--- .../Tests/Unit/HttpApiHandlerTests.cs | 5 +- .../Tests/Unit/LocalGrpcListenerTests.cs | 2 +- 6 files changed, 133 insertions(+), 38 deletions(-) diff --git a/src/WebJobs.Extensions.DurableTask/ContextImplementations/DurableClient.cs b/src/WebJobs.Extensions.DurableTask/ContextImplementations/DurableClient.cs index fa05cfea5..5e88dce3b 100644 --- a/src/WebJobs.Extensions.DurableTask/ContextImplementations/DurableClient.cs +++ b/src/WebJobs.Extensions.DurableTask/ContextImplementations/DurableClient.cs @@ -178,12 +178,13 @@ async Task IDurableOrchestrationClient.WaitForCompletionOrCreateC /// async Task IDurableOrchestrationClient.StartNewAsync(string orchestratorFunctionName, string instanceId, T input) { - if (this.ReferencesCurrentApp()) + if (this.ClientReferencesCurrentApp(this)) { this.config?.ThrowIfFunctionDoesNotExist(orchestratorFunctionName, FunctionType.Orchestrator); - this.config?.ThrowIfOrchestratorFunctionIsDisabled(orchestratorFunctionName); } + this.ThrowIfOrchestratorFunctionIsDisabled(orchestratorFunctionName); + if (string.IsNullOrEmpty(instanceId)) { instanceId = Guid.NewGuid().ToString("N"); @@ -364,18 +365,34 @@ private bool ClientReferencesCurrentApp(DurableClient client) this.ConnectionNameMatchesCurrentApp(client); } - internal bool ReferencesCurrentApp() + internal void ThrowIfOrchestratorFunctionIsDisabled(string name) { - return this.ClientReferencesCurrentApp(this); + if (this.ClientTargetsCurrentAppForDisabledCheck()) + { + this.config.ThrowIfOrchestratorFunctionIsDisabled(name); + } } private bool TaskHubMatchesCurrentApp(DurableClient client) { var taskHubName = this.durableTaskOptions.HubName; - StringComparison comparison = UsesCaseInsensitiveTaskHubNames(this.config?.DefaultDurabilityProvider) + return client.TaskHubName.Equals(taskHubName); + } + + private bool ClientTargetsCurrentAppForDisabledCheck() + { + return this.config != null && + !this.attribute.ExternalClient && + this.TaskHubMatchesCurrentAppForDisabledCheck() && + this.config.DefaultDurabilityProvider.ConnectionNameMatches(this.DurabilityProvider); + } + + private bool TaskHubMatchesCurrentAppForDisabledCheck() + { + StringComparison comparison = UsesCaseInsensitiveTaskHubNames(this.config.DefaultDurabilityProvider) ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal; - return string.Equals(client.TaskHubName, taskHubName, comparison); + return string.Equals(this.TaskHubName, this.durableTaskOptions.HubName, comparison); } private static bool UsesCaseInsensitiveTaskHubNames(DurabilityProvider provider) @@ -387,8 +404,7 @@ private static bool UsesCaseInsensitiveTaskHubNames(DurabilityProvider provider) private bool ConnectionNameMatchesCurrentApp(DurableClient client) { - return this.config != null && - this.config.DefaultDurabilityProvider.ConnectionNameMatches(client.DurabilityProvider); + return this.DurabilityProvider.ConnectionNameMatches(client.DurabilityProvider); } /// @@ -1282,10 +1298,7 @@ async Task IDurableOrchestrationClient.RestartAsync(string instanceId, b // GetOrchestrationInstanceStateAsync will throw ArgumentException if the provided instanceid is not found. OrchestrationState state = await this.GetOrchestrationInstanceStateAsync(instanceId); - if (this.ReferencesCurrentApp()) - { - this.config?.ThrowIfOrchestratorFunctionIsDisabled(state.Name); - } + this.ThrowIfOrchestratorFunctionIsDisabled(state.Name); JToken input = ParseToJToken(state.Input); diff --git a/src/WebJobs.Extensions.DurableTask/HttpApiHandler.cs b/src/WebJobs.Extensions.DurableTask/HttpApiHandler.cs index ff3219222..b7b9d9f24 100644 --- a/src/WebJobs.Extensions.DurableTask/HttpApiHandler.cs +++ b/src/WebJobs.Extensions.DurableTask/HttpApiHandler.cs @@ -958,10 +958,7 @@ private async Task HandleStartOrchestratorRequestAsync( if (client is DurableClient durableClient) { - if (durableClient.ReferencesCurrentApp()) - { - this.config.ThrowIfOrchestratorFunctionIsDisabled(functionName); - } + durableClient.ThrowIfOrchestratorFunctionIsDisabled(functionName); var instance = new OrchestrationInstance { diff --git a/src/WebJobs.Extensions.DurableTask/TaskHubGrpcServer.cs b/src/WebJobs.Extensions.DurableTask/TaskHubGrpcServer.cs index c8c420e0d..b3f3f5f3b 100644 --- a/src/WebJobs.Extensions.DurableTask/TaskHubGrpcServer.cs +++ b/src/WebJobs.Extensions.DurableTask/TaskHubGrpcServer.cs @@ -59,9 +59,9 @@ public override Task Hello(Empty request, ServerCallContext context) { try { - if (this.GetClient(context) is DurableClient durableClient && durableClient.ReferencesCurrentApp()) + if (this.GetClient(context) is DurableClient durableClient) { - this.extension.ThrowIfOrchestratorFunctionIsDisabled(request.Name); + durableClient.ThrowIfOrchestratorFunctionIsDisabled(request.Name); } List allStatuses = System.Enum diff --git a/test/FunctionsV2/Tests/Unit/DurableClientBaseTests.cs b/test/FunctionsV2/Tests/Unit/DurableClientBaseTests.cs index cee398efd..40dc52d0f 100644 --- a/test/FunctionsV2/Tests/Unit/DurableClientBaseTests.cs +++ b/test/FunctionsV2/Tests/Unit/DurableClientBaseTests.cs @@ -82,12 +82,28 @@ public async Task StartNewAsync_MissingOrchestrator_ThrowsException() [Fact] [Trait("Category", PlatformSpecificHelpers.TestCategory)] - public async Task StartNewAsync_DifferentConnection_DoesNotValidateLocalOrchestrator() + public async Task StartNewAsync_DifferentConnection_MissingOrchestrator_ThrowsException() { - (DurableClient durableClient, Mock serviceClient) = - CreateCrossConnectionClient(); + (DurableClient durableClient, Mock serviceClient, _) = + CreateClient(); - await ((IDurableOrchestrationClient)durableClient).StartNewAsync("RemoteOrchestrator"); + ArgumentException exception = await Assert.ThrowsAsync( + () => ((IDurableOrchestrationClient)durableClient).StartNewAsync("MissingOrchestrator")); + + Assert.Contains("doesn't exist, is disabled, or is not an orchestrator function", exception.Message); + serviceClient.Verify( + x => x.CreateTaskOrchestrationAsync(It.IsAny(), It.IsAny()), + Times.Never()); + } + + [Fact] + [Trait("Category", PlatformSpecificHelpers.TestCategory)] + public async Task StartNewAsync_CaseVariantTaskHub_MissingOrchestrator_SchedulesInstance() + { + (DurableClient durableClient, Mock serviceClient, _) = + CreateClient(taskHub: "durabletaskhub", connectionName: TestConstants.ConnectionName); + + await ((IDurableOrchestrationClient)durableClient).StartNewAsync("MissingOrchestrator"); serviceClient.Verify( x => x.CreateTaskOrchestrationAsync(It.IsAny(), It.IsAny()), @@ -143,6 +159,22 @@ public async Task StartNewAsync_DisabledOrchestrator_UsesDefaultProviderTaskHubC rejectStart ? Times.Never() : Times.Once()); } + [Fact] + [Trait("Category", PlatformSpecificHelpers.TestCategory)] + public async Task StartNewAsync_DifferentConnection_DisabledOrchestrator_SchedulesInstance() + { + const string FunctionName = "DisabledOrchestrator"; + (DurableClient durableClient, Mock serviceClient, DurableTaskExtension extension) = + CreateClient(); + extension.RegisterOrchestrator(new FunctionName(FunctionName), orchestratorInfo: null); + + await ((IDurableOrchestrationClient)durableClient).StartNewAsync(FunctionName); + + serviceClient.Verify( + x => x.CreateTaskOrchestrationAsync(It.IsAny(), It.IsAny()), + Times.Once()); + } + [Theory] [InlineData(null)] [InlineData("durabletaskhub")] @@ -190,6 +222,38 @@ public async Task RestartAsync_DisabledOrchestrator_ThrowsException(string taskH Times.Never()); } + [Fact] + [Trait("Category", PlatformSpecificHelpers.TestCategory)] + public async Task RestartAsync_DifferentConnection_DisabledOrchestrator_SchedulesInstance() + { + const string InstanceId = "completed-instance"; + const string FunctionName = "DisabledOrchestrator"; + (DurableClient durableClient, Mock serviceClient, DurableTaskExtension extension) = + CreateClient(); + serviceClient + .Setup(x => x.GetOrchestrationStateAsync(InstanceId, false)) + .ReturnsAsync( + new List + { + new OrchestrationState + { + Name = FunctionName, + Input = "null", + OrchestrationInstance = new OrchestrationInstance { InstanceId = InstanceId }, + OrchestrationStatus = OrchestrationStatus.Completed, + }, + }); + extension.RegisterOrchestrator(new FunctionName(FunctionName), orchestratorInfo: null); + + await ((IDurableOrchestrationClient)durableClient).RestartAsync( + InstanceId, + restartWithNewInstanceId: false); + + serviceClient.Verify( + x => x.CreateTaskOrchestrationAsync(It.IsAny(), It.IsAny()), + Times.Once()); + } + [Fact] [Trait("Category", PlatformSpecificHelpers.TestCategory)] public async Task StartNewAsync_DeregisteredOrchestrator_SchedulesInstance() @@ -254,13 +318,32 @@ public async Task SignalEntity_InvalidEntityKey_ThrowsException(string entityKey [Fact] [Trait("Category", PlatformSpecificHelpers.TestCategory)] - public async Task SignalEntityAsync_DifferentConnection_DoesNotValidateLocalEntity() + public async Task SignalEntityAsync_DifferentConnection_MissingEntity_ThrowsException() + { + (DurableClient durableClient, Mock serviceClient, _) = + CreateClient(); + + ArgumentException exception = await Assert.ThrowsAsync( + () => ((IDurableEntityClient)durableClient).SignalEntityAsync( + new EntityId("MissingEntity", "entity-key"), + "operation", + new { Value = 1 })); + + Assert.Contains("doesn't exist, is disabled, or is not an entity function", exception.Message); + serviceClient.Verify( + x => x.SendTaskOrchestrationMessageAsync(It.IsAny()), + Times.Never()); + } + + [Fact] + [Trait("Category", PlatformSpecificHelpers.TestCategory)] + public async Task SignalEntityAsync_CaseVariantTaskHub_MissingEntity_SendsMessage() { - (DurableClient durableClient, Mock serviceClient) = - CreateCrossConnectionClient(); + (DurableClient durableClient, Mock serviceClient, _) = + CreateClient(taskHub: "durabletaskhub", connectionName: TestConstants.ConnectionName); await ((IDurableEntityClient)durableClient).SignalEntityAsync( - new EntityId("RemoteEntity", "entity-key"), + new EntityId("MissingEntity", "entity-key"), "operation", new { Value = 1 }); @@ -533,9 +616,13 @@ private IDurableOrchestrationClient GetDurableClient(IOrchestrationServiceClient return durableOrchestrationClient; } - private static (DurableClient Client, Mock ServiceClient) CreateCrossConnectionClient() + private static ( + DurableClient Client, + Mock ServiceClient, + DurableTaskExtension Extension) CreateClient( + string taskHub = "DurableTaskHub", + string connectionName = "TargetStorage") { - const string TargetConnectionName = "TargetStorage"; var serviceClient = new Mock(); serviceClient .Setup(x => x.CreateTaskOrchestrationAsync(It.IsAny(), It.IsAny())) @@ -547,15 +634,12 @@ private static (DurableClient Client, Mock ServiceC "clientProvider", new Mock().Object, serviceClient.Object, - TargetConnectionName); + connectionName); var durableExtension = GetDurableTaskConfig(); - Assert.NotEqual( - durableExtension.DefaultDurabilityProvider.ConnectionName, - storageProvider.ConnectionName); var attribute = new DurableClientAttribute { - TaskHub = durableExtension.Options.HubName, - ConnectionName = TargetConnectionName, + TaskHub = taskHub, + ConnectionName = connectionName, ExternalClient = false, }; var client = new DurableClient( @@ -563,7 +647,7 @@ private static (DurableClient Client, Mock ServiceC durableExtension, durableExtension.HttpApiHandler, attribute); - return (client, serviceClient); + return (client, serviceClient, durableExtension); } [Fact] diff --git a/test/FunctionsV2/Tests/Unit/HttpApiHandlerTests.cs b/test/FunctionsV2/Tests/Unit/HttpApiHandlerTests.cs index 0460f5234..b76d6416b 100644 --- a/test/FunctionsV2/Tests/Unit/HttpApiHandlerTests.cs +++ b/test/FunctionsV2/Tests/Unit/HttpApiHandlerTests.cs @@ -2132,11 +2132,11 @@ public async Task StartNewInstance_Returns_HTTP_400_On_Disabled_Function(bool us [InlineData("taskHub=RemoteHub", TestConstants.ConnectionName)] [InlineData("connection=TestConnection", TestConstants.CustomConnectionName)] [Trait("Category", PlatformSpecificHelpers.TestCategory)] - public async Task StartNewInstance_ExternalTarget_DoesNotValidateLocalFunction( + public async Task StartNewInstance_ExternalTarget_DoesNotRejectLocallyDisabledFunction( string query, string providerConnectionName) { - const string FunctionName = "RemoteOrchestrator"; + const string FunctionName = "DisabledOrchestrator"; var requestUri = new Uri( $"http://localhost/runtime/webhooks/durabletask/orchestrators/{FunctionName}?{query}"); var orchestrationServiceMock = new Mock(MockBehavior.Strict); @@ -2157,6 +2157,7 @@ public async Task StartNewInstance_ExternalTarget_DoesNotValidateLocalFunction( HubName = TestConstants.TaskHub, }; var extension = TestDurableTaskExtension.CreateWithProvider(options, durabilityProvider); + extension.RegisterOrchestrator(new FunctionName(FunctionName), orchestratorInfo: null); var handler = new HttpApiHandler(extension, NullLogger.Instance); HttpResponseMessage response = await handler.HandleRequestAsync( diff --git a/test/FunctionsV2/Tests/Unit/LocalGrpcListenerTests.cs b/test/FunctionsV2/Tests/Unit/LocalGrpcListenerTests.cs index e32221aeb..50e52fc57 100644 --- a/test/FunctionsV2/Tests/Unit/LocalGrpcListenerTests.cs +++ b/test/FunctionsV2/Tests/Unit/LocalGrpcListenerTests.cs @@ -323,7 +323,7 @@ public async Task TestGrpcListener_RejectsDisabledOrchestrator(bool useCaseVaria [InlineData(true)] [InlineData(false)] [Trait("Category", PlatformSpecificHelpers.TestCategory)] - public async Task TestGrpcListener_ExternalTarget_DoesNotValidateLocalFunction(bool useRemoteTaskHub) + public async Task TestGrpcListener_ExternalTarget_DoesNotRejectLocallyDisabledFunction(bool useRemoteTaskHub) { const string FunctionName = "RemoteOrchestrator"; const string RemoteConnectionName = "RemoteConnection"; From 7804b3ed24c03da981dfa95b074cf2146a168870 Mon Sep 17 00:00:00 2001 From: wangbill Date: Wed, 19 Aug 2026 17:30:47 -0400 Subject: [PATCH 13/13] Reuse legacy current-app validation gate Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> Copilot-Session: e84c5737-8808-4d03-901a-49afc08fbcf0 --- .../ContextImplementations/DurableClient.cs | 29 +--- .../DurabilityProvider.cs | 2 - .../Tests/E2E/StatusAndQueryTests.cs | 13 +- .../Tests/Unit/DurableClientBaseTests.cs | 139 +++++++++++------- .../Tests/Unit/HttpApiHandlerTests.cs | 30 ++-- .../Tests/Unit/LocalGrpcListenerTests.cs | 95 +++++++----- 6 files changed, 162 insertions(+), 146 deletions(-) diff --git a/src/WebJobs.Extensions.DurableTask/ContextImplementations/DurableClient.cs b/src/WebJobs.Extensions.DurableTask/ContextImplementations/DurableClient.cs index 5e88dce3b..4ff2b491c 100644 --- a/src/WebJobs.Extensions.DurableTask/ContextImplementations/DurableClient.cs +++ b/src/WebJobs.Extensions.DurableTask/ContextImplementations/DurableClient.cs @@ -30,8 +30,6 @@ internal class DurableClient : IDurableClient, #pragma warning restore 618 { private const int MaxInstanceIdLength = 256; - private const string AzureStorageProviderName = "Azure Storage"; - private const string AzureManagedProviderName = "azureManaged"; private static readonly JValue NullJValue = JValue.CreateNull(); private static readonly OrchestrationRuntimeStatus[] RunningStatus @@ -367,9 +365,9 @@ private bool ClientReferencesCurrentApp(DurableClient client) internal void ThrowIfOrchestratorFunctionIsDisabled(string name) { - if (this.ClientTargetsCurrentAppForDisabledCheck()) + if (this.ClientReferencesCurrentApp(this)) { - this.config.ThrowIfOrchestratorFunctionIsDisabled(name); + this.config?.ThrowIfOrchestratorFunctionIsDisabled(name); } } @@ -379,29 +377,6 @@ private bool TaskHubMatchesCurrentApp(DurableClient client) return client.TaskHubName.Equals(taskHubName); } - private bool ClientTargetsCurrentAppForDisabledCheck() - { - return this.config != null && - !this.attribute.ExternalClient && - this.TaskHubMatchesCurrentAppForDisabledCheck() && - this.config.DefaultDurabilityProvider.ConnectionNameMatches(this.DurabilityProvider); - } - - private bool TaskHubMatchesCurrentAppForDisabledCheck() - { - StringComparison comparison = UsesCaseInsensitiveTaskHubNames(this.config.DefaultDurabilityProvider) - ? StringComparison.OrdinalIgnoreCase - : StringComparison.Ordinal; - return string.Equals(this.TaskHubName, this.durableTaskOptions.HubName, comparison); - } - - private static bool UsesCaseInsensitiveTaskHubNames(DurabilityProvider provider) - { - return provider != null && - (string.Equals(provider.Name, AzureStorageProviderName, StringComparison.OrdinalIgnoreCase) || - string.Equals(provider.Name, AzureManagedProviderName, StringComparison.OrdinalIgnoreCase)); - } - private bool ConnectionNameMatchesCurrentApp(DurableClient client) { return this.DurabilityProvider.ConnectionNameMatches(client.DurabilityProvider); diff --git a/src/WebJobs.Extensions.DurableTask/DurabilityProvider.cs b/src/WebJobs.Extensions.DurableTask/DurabilityProvider.cs index 57f4f66ab..5d27d59d8 100644 --- a/src/WebJobs.Extensions.DurableTask/DurabilityProvider.cs +++ b/src/WebJobs.Extensions.DurableTask/DurabilityProvider.cs @@ -66,8 +66,6 @@ public DurabilityProvider(string storageProviderName, IOrchestrationService serv /// public virtual string ConnectionName => this.connectionName; - internal string Name => this.name; - /// /// Specifies whether the durability provider supports Durable Entities. /// diff --git a/test/FunctionsV2/Tests/E2E/StatusAndQueryTests.cs b/test/FunctionsV2/Tests/E2E/StatusAndQueryTests.cs index 17079a12f..25b8879b5 100644 --- a/test/FunctionsV2/Tests/E2E/StatusAndQueryTests.cs +++ b/test/FunctionsV2/Tests/E2E/StatusAndQueryTests.cs @@ -59,13 +59,12 @@ public async Task StartOrchestration_OnUnregisteredOrchestrator(bool extendedSes [Fact] [Trait("Category", PlatformSpecificHelpers.TestCategory)] - public async Task DisabledOrchestrator_CaseVariantTaskHub_IsRejectedWithoutPersistingInstance() + public async Task DisabledOrchestrator_IsRejectedWithoutPersistingInstance() { - const string InstanceId = "disabled-case-variant-instance"; + const string InstanceId = "disabled-orchestrator-instance"; string taskHubName = TestHelpers.GetTaskHubNameFromTestName( - nameof(this.DisabledOrchestrator_CaseVariantTaskHub_IsRejectedWithoutPersistingInstance), - enableExtendedSessions: false).ToLowerInvariant(); - string hostTaskHubName = char.ToUpperInvariant(taskHubName[0]) + taskHubName.Substring(1); + nameof(this.DisabledOrchestrator_IsRejectedWithoutPersistingInstance), + enableExtendedSessions: false); var nameResolver = new SimpleNameResolver( new Dictionary { @@ -74,11 +73,11 @@ public async Task DisabledOrchestrator_CaseVariantTaskHub_IsRejectedWithoutPersi using (ITestHost host = TestHelpers.GetJobHost( this.loggerProvider, - nameof(this.DisabledOrchestrator_CaseVariantTaskHub_IsRejectedWithoutPersistingInstance), + nameof(this.DisabledOrchestrator_IsRejectedWithoutPersistingInstance), enableExtendedSessions: false, nameResolver: nameResolver, storageProviderType: TestHelpers.AzureStorageProviderType, - exactTaskHubName: hostTaskHubName)) + exactTaskHubName: taskHubName)) { await host.StartAsync(); diff --git a/test/FunctionsV2/Tests/Unit/DurableClientBaseTests.cs b/test/FunctionsV2/Tests/Unit/DurableClientBaseTests.cs index 40dc52d0f..1ae8300b2 100644 --- a/test/FunctionsV2/Tests/Unit/DurableClientBaseTests.cs +++ b/test/FunctionsV2/Tests/Unit/DurableClientBaseTests.cs @@ -111,18 +111,11 @@ public async Task StartNewAsync_CaseVariantTaskHub_MissingOrchestrator_Schedules } [Theory] - [InlineData("Azure Storage", null, true)] - [InlineData("Azure Storage", "durabletaskhub", true)] - [InlineData("azureManaged", "durabletaskhub", true)] - [InlineData("mssql", "durabletaskhub", false)] - [InlineData("mssql", "DurableTaskHub", true)] - [InlineData("Netherite", "durabletaskhub", false)] - [InlineData("Netherite", "DurableTaskHub", true)] - [InlineData("custom", "durabletaskhub", false)] - [InlineData("custom", "DurableTaskHub", true)] + [InlineData(null, true)] + [InlineData("DurableTaskHub", true)] + [InlineData("durabletaskhub", false)] [Trait("Category", PlatformSpecificHelpers.TestCategory)] - public async Task StartNewAsync_DisabledOrchestrator_UsesDefaultProviderTaskHubCaseSensitivity( - string defaultProviderName, + public async Task StartNewAsync_DisabledOrchestrator_UsesLegacyTaskHubMatching( string taskHub, bool rejectStart) { @@ -135,7 +128,7 @@ public async Task StartNewAsync_DisabledOrchestrator_UsesDefaultProviderTaskHubC new Mock().Object, orchestrationServiceClientMock.Object, TestConstants.ConnectionName); - var durableExtension = GetDurableTaskConfig(defaultProviderName); + var durableExtension = GetDurableTaskConfig(); durableExtension.RegisterOrchestrator(new FunctionName("DisabledOrchestrator"), orchestratorInfo: null); var durableClient = (IDurableOrchestrationClient)new DurableClient( storageProvider, @@ -161,25 +154,29 @@ public async Task StartNewAsync_DisabledOrchestrator_UsesDefaultProviderTaskHubC [Fact] [Trait("Category", PlatformSpecificHelpers.TestCategory)] - public async Task StartNewAsync_DifferentConnection_DisabledOrchestrator_SchedulesInstance() + public async Task StartNewAsync_DifferentConnection_DisabledOrchestrator_ThrowsException() { const string FunctionName = "DisabledOrchestrator"; (DurableClient durableClient, Mock serviceClient, DurableTaskExtension extension) = CreateClient(); extension.RegisterOrchestrator(new FunctionName(FunctionName), orchestratorInfo: null); - await ((IDurableOrchestrationClient)durableClient).StartNewAsync(FunctionName); + await Assert.ThrowsAsync( + () => ((IDurableOrchestrationClient)durableClient).StartNewAsync(FunctionName)); serviceClient.Verify( x => x.CreateTaskOrchestrationAsync(It.IsAny(), It.IsAny()), - Times.Once()); + Times.Never()); } [Theory] - [InlineData(null)] - [InlineData("durabletaskhub")] + [InlineData(null, true)] + [InlineData("DurableTaskHub", true)] + [InlineData("durabletaskhub", false)] [Trait("Category", PlatformSpecificHelpers.TestCategory)] - public async Task RestartAsync_DisabledOrchestrator_ThrowsException(string taskHub) + public async Task RestartAsync_DisabledOrchestrator_UsesLegacyTaskHubMatching( + string taskHub, + bool rejectRestart) { const string InstanceId = "completed-instance"; const string FunctionName = "DisabledOrchestrator"; @@ -213,18 +210,25 @@ public async Task RestartAsync_DisabledOrchestrator_ThrowsException(string taskH durableExtension.HttpApiHandler, new DurableClientAttribute { TaskHub = taskHub }); - ArgumentException exception = await Assert.ThrowsAnyAsync( - () => durableClient.RestartAsync(InstanceId, restartWithNewInstanceId: false)); + if (rejectRestart) + { + ArgumentException exception = await Assert.ThrowsAnyAsync( + () => durableClient.RestartAsync(InstanceId, restartWithNewInstanceId: false)); + Assert.Contains("doesn't exist, is disabled, or is not an orchestrator function", exception.Message); + } + else + { + await durableClient.RestartAsync(InstanceId, restartWithNewInstanceId: false); + } - Assert.Contains("doesn't exist, is disabled, or is not an orchestrator function", exception.Message); orchestrationServiceClientMock.Verify( x => x.CreateTaskOrchestrationAsync(It.IsAny(), It.IsAny()), - Times.Never()); + rejectRestart ? Times.Never() : Times.Once()); } [Fact] [Trait("Category", PlatformSpecificHelpers.TestCategory)] - public async Task RestartAsync_DifferentConnection_DisabledOrchestrator_SchedulesInstance() + public async Task RestartAsync_DifferentConnection_DisabledOrchestrator_ThrowsException() { const string InstanceId = "completed-instance"; const string FunctionName = "DisabledOrchestrator"; @@ -245,6 +249,61 @@ public async Task RestartAsync_DifferentConnection_DisabledOrchestrator_Schedule }); extension.RegisterOrchestrator(new FunctionName(FunctionName), orchestratorInfo: null); + await Assert.ThrowsAsync( + () => ((IDurableOrchestrationClient)durableClient).RestartAsync( + InstanceId, + restartWithNewInstanceId: false)); + + serviceClient.Verify( + x => x.CreateTaskOrchestrationAsync(It.IsAny(), It.IsAny()), + Times.Never()); + } + + [Theory] + [InlineData("MissingOrchestrator", false)] + [InlineData("DisabledOrchestrator", true)] + [Trait("Category", PlatformSpecificHelpers.TestCategory)] + public async Task StartNewAsync_ExternalClient_BypassesLocalValidation( + string functionName, + bool registerDisabled) + { + (DurableClient durableClient, Mock serviceClient, DurableTaskExtension extension) = + CreateClient(externalClient: true); + if (registerDisabled) + { + extension.RegisterOrchestrator(new FunctionName(functionName), orchestratorInfo: null); + } + + await ((IDurableOrchestrationClient)durableClient).StartNewAsync(functionName); + + serviceClient.Verify( + x => x.CreateTaskOrchestrationAsync(It.IsAny(), It.IsAny()), + Times.Once()); + } + + [Fact] + [Trait("Category", PlatformSpecificHelpers.TestCategory)] + public async Task RestartAsync_ExternalClient_BypassesDisabledValidation() + { + const string InstanceId = "completed-instance"; + const string FunctionName = "DisabledOrchestrator"; + (DurableClient durableClient, Mock serviceClient, DurableTaskExtension extension) = + CreateClient(externalClient: true); + serviceClient + .Setup(x => x.GetOrchestrationStateAsync(InstanceId, false)) + .ReturnsAsync( + new List + { + new OrchestrationState + { + Name = FunctionName, + Input = "null", + OrchestrationInstance = new OrchestrationInstance { InstanceId = InstanceId }, + OrchestrationStatus = OrchestrationStatus.Completed, + }, + }); + extension.RegisterOrchestrator(new FunctionName(FunctionName), orchestratorInfo: null); + await ((IDurableOrchestrationClient)durableClient).RestartAsync( InstanceId, restartWithNewInstanceId: false); @@ -621,7 +680,8 @@ private static ( Mock ServiceClient, DurableTaskExtension Extension) CreateClient( string taskHub = "DurableTaskHub", - string connectionName = "TargetStorage") + string connectionName = "TargetStorage", + bool externalClient = false) { var serviceClient = new Mock(); serviceClient @@ -640,7 +700,7 @@ private static ( { TaskHub = taskHub, ConnectionName = connectionName, - ExternalClient = false, + ExternalClient = externalClient, }; var client = new DurableClient( storageProvider, @@ -773,35 +833,6 @@ private static DurableTaskExtension GetDurableTaskConfig() platformInformationService: platformInformationService); } - private static DurableTaskExtension GetDurableTaskConfig(string defaultProviderName) - { - var options = new DurableTaskOptions - { - HubName = "DurableTaskHub", - WebhookUriProviderOverride = () => new Uri("https://sampleurl.net"), - }; - options.StorageProvider["type"] = defaultProviderName; - var wrappedOptions = new OptionsWrapper(options); - var nameResolver = TestHelpers.GetTestNameResolver(); - var platformInformationService = TestHelpers.GetMockPlatformInformationService(); - var defaultProvider = new DurabilityProvider( - defaultProviderName, - new Mock().Object, - new Mock().Object, - TestConstants.ConnectionName); - var serviceFactory = new Mock(); - serviceFactory.SetupGet(factory => factory.Name).Returns(defaultProviderName); - serviceFactory.Setup(factory => factory.GetDurabilityProvider()).Returns(defaultProvider); - return new DurableTaskExtension( - wrappedOptions, - new LoggerFactory(), - nameResolver, - new[] { serviceFactory.Object }, - new TestHostShutdownNotificationService(), - new DurableHttpMessageHandlerFactory(), - platformInformationService: platformInformationService); - } - // wraps the durability provider class so we can configure the CheckStatusBeforeRaiseEvent property private class DurabilityProvider : Microsoft.Azure.WebJobs.Extensions.DurableTask.DurabilityProvider { diff --git a/test/FunctionsV2/Tests/Unit/HttpApiHandlerTests.cs b/test/FunctionsV2/Tests/Unit/HttpApiHandlerTests.cs index b76d6416b..e4a31e767 100644 --- a/test/FunctionsV2/Tests/Unit/HttpApiHandlerTests.cs +++ b/test/FunctionsV2/Tests/Unit/HttpApiHandlerTests.cs @@ -1362,17 +1362,14 @@ public async Task RestartInstance_Returns_HTTP_400_On_Invalid_InstanceId() Assert.Equal("InstanceId does not match a valid orchestration instance.", error["Message"].ToString()); } - [Theory] - [InlineData(false)] - [InlineData(true)] + [Fact] [Trait("Category", PlatformSpecificHelpers.TestCategory)] - public async Task RestartInstance_Returns_HTTP_400_On_Disabled_Function(bool useCaseVariantTaskHub) + public async Task RestartInstance_Returns_HTTP_400_On_Disabled_Function() { const string InstanceId = "completed-instance"; const string FunctionName = "DisabledOrchestrator"; - string query = useCaseVariantTaskHub ? $"?taskHub={TestConstants.TaskHub.ToLowerInvariant()}" : string.Empty; var requestUri = new Uri( - $"http://localhost/runtime/webhooks/durabletask/instances/{InstanceId}/restart{query}"); + $"http://localhost/runtime/webhooks/durabletask/instances/{InstanceId}/restart"); var orchestrationServiceMock = new Mock(MockBehavior.Strict); var orchestrationServiceClientMock = new Mock(); orchestrationServiceClientMock @@ -2083,16 +2080,13 @@ public async Task StartNewInstance_Calls_CreateTaskOrchestrationAsync_With_Corre Assert.Equal(expectedVersion, capturedEvent.Version); } - [Theory] - [InlineData(false)] - [InlineData(true)] + [Fact] [Trait("Category", PlatformSpecificHelpers.TestCategory)] - public async Task StartNewInstance_Returns_HTTP_400_On_Disabled_Function(bool useCaseVariantTaskHub) + public async Task StartNewInstance_Returns_HTTP_400_On_Disabled_Function() { const string FunctionName = "DisabledOrchestrator"; - string query = useCaseVariantTaskHub ? $"?taskHub={TestConstants.TaskHub.ToLowerInvariant()}" : string.Empty; var requestUri = new Uri( - $"http://localhost/runtime/webhooks/durabletask/orchestrators/{FunctionName}{query}"); + $"http://localhost/runtime/webhooks/durabletask/orchestrators/{FunctionName}"); var orchestrationServiceMock = new Mock(MockBehavior.Strict); var orchestrationServiceClientMock = new Mock(); orchestrationServiceClientMock @@ -2128,17 +2122,13 @@ public async Task StartNewInstance_Returns_HTTP_400_On_Disabled_Function(bool us Times.Never); } - [Theory] - [InlineData("taskHub=RemoteHub", TestConstants.ConnectionName)] - [InlineData("connection=TestConnection", TestConstants.CustomConnectionName)] + [Fact] [Trait("Category", PlatformSpecificHelpers.TestCategory)] - public async Task StartNewInstance_ExternalTarget_DoesNotRejectLocallyDisabledFunction( - string query, - string providerConnectionName) + public async Task StartNewInstance_CaseVariantTaskHub_DoesNotRejectLocallyDisabledFunction() { const string FunctionName = "DisabledOrchestrator"; var requestUri = new Uri( - $"http://localhost/runtime/webhooks/durabletask/orchestrators/{FunctionName}?{query}"); + $"http://localhost/runtime/webhooks/durabletask/orchestrators/{FunctionName}?taskHub=testhubname"); var orchestrationServiceMock = new Mock(MockBehavior.Strict); var orchestrationServiceClientMock = new Mock(); orchestrationServiceClientMock @@ -2150,7 +2140,7 @@ public async Task StartNewInstance_ExternalTarget_DoesNotRejectLocallyDisabledFu "storageProviderName", orchestrationServiceMock.Object, orchestrationServiceClientMock.Object, - providerConnectionName); + TestConstants.ConnectionName); var options = new DurableTaskOptions { WebhookUriProviderOverride = () => new Uri("http://localhost/runtime/webhooks/durabletask"), diff --git a/test/FunctionsV2/Tests/Unit/LocalGrpcListenerTests.cs b/test/FunctionsV2/Tests/Unit/LocalGrpcListenerTests.cs index 50e52fc57..4d4bf8ce9 100644 --- a/test/FunctionsV2/Tests/Unit/LocalGrpcListenerTests.cs +++ b/test/FunctionsV2/Tests/Unit/LocalGrpcListenerTests.cs @@ -279,16 +279,11 @@ public async Task TestGrpcListener_DoesNotLogStartInstanceClientCancellation() message.FormattedMessage.Contains("StartInstance")); } - [Theory] - [InlineData(false)] - [InlineData(true)] + [Fact] [Trait("Category", PlatformSpecificHelpers.TestCategory)] - public async Task TestGrpcListener_RejectsDisabledOrchestrator(bool useCaseVariantTaskHub) + public async Task TestGrpcListener_RejectsDisabledOrchestrator() { const string FunctionName = "DisabledOrchestrator"; - Metadata headers = useCaseVariantTaskHub - ? new Metadata { { TaskHubMetadataKey, "disabledorchestratorstart" } } - : null; Mock durabilityProvider = CreateDurabilityProviderMock( new Mock().Object, new Mock().Object); @@ -303,8 +298,7 @@ public async Task TestGrpcListener_RejectsDisabledOrchestrator(bool useCaseVaria "DisabledOrchestratorStart", durabilityProvider.Object, async client => await client.StartInstanceAsync( - new P.CreateInstanceRequest { Name = FunctionName }, - headers).ResponseAsync, + new P.CreateInstanceRequest { Name = FunctionName }).ResponseAsync, extension => extension.RegisterOrchestrator( new FunctionName(FunctionName), orchestratorInfo: null)); @@ -319,34 +313,24 @@ public async Task TestGrpcListener_RejectsDisabledOrchestrator(bool useCaseVaria Times.Never); } - [Theory] - [InlineData(true)] - [InlineData(false)] + [Fact] [Trait("Category", PlatformSpecificHelpers.TestCategory)] - public async Task TestGrpcListener_ExternalTarget_DoesNotRejectLocallyDisabledFunction(bool useRemoteTaskHub) + public async Task TestGrpcListener_CaseVariantTaskHub_DoesNotRejectLocallyDisabledFunction() { const string FunctionName = "RemoteOrchestrator"; - const string RemoteConnectionName = "RemoteConnection"; Mock durabilityProvider = CreateDurabilityProviderMock( new Mock().Object, - new Mock().Object, - useRemoteTaskHub ? "TestConnection" : RemoteConnectionName); + new Mock().Object); durabilityProvider .Setup(provider => provider.CreateTaskOrchestrationAsync( It.IsAny(), It.IsAny(), It.IsAny())) .Returns(Task.CompletedTask); - DurabilityProvider defaultDurabilityProvider = useRemoteTaskHub - ? durabilityProvider.Object - : CreateDurabilityProviderMock( - new Mock().Object, - new Mock().Object, - "DefaultConnection").Object; using DurableTaskExtension extension = this.CreateExtension( "CurrentHub", durabilityProvider.Object, - defaultDurabilityProvider); + durabilityProvider.Object); extension.RegisterOrchestrator(new FunctionName(FunctionName), orchestratorInfo: null); ILocalGrpcListener listener = LocalGrpcListener.Create( extension, @@ -357,9 +341,7 @@ public async Task TestGrpcListener_ExternalTarget_DoesNotRejectLocallyDisabledFu await listener.StartAsync(default); using GrpcChannel channel = GrpcChannel.ForAddress(listener.ListenAddress); var client = new P.TaskHubSidecarService.TaskHubSidecarServiceClient(channel); - var headers = useRemoteTaskHub - ? new Metadata { { TaskHubMetadataKey, "RemoteHub" } } - : new Metadata { { "Durable-ConnectionName", RemoteConnectionName } }; + var headers = new Metadata { { TaskHubMetadataKey, "currenthub" } }; await client.StartInstanceAsync( new P.CreateInstanceRequest { Name = FunctionName }, @@ -378,17 +360,39 @@ await client.StartInstanceAsync( Times.Once); } - [Theory] - [InlineData(false)] - [InlineData(true)] + [Fact] [Trait("Category", PlatformSpecificHelpers.TestCategory)] - public async Task TestGrpcListener_RestartRejectsDisabledOrchestrator(bool useCaseVariantTaskHub) + public async Task TestGrpcListener_UnknownOrchestrator_SchedulesInstance() + { + Mock durabilityProvider = CreateDurabilityProviderMock( + new Mock().Object, + new Mock().Object); + durabilityProvider + .Setup(provider => provider.CreateTaskOrchestrationAsync( + It.IsAny(), + It.IsAny(), + It.IsAny())) + .Returns(Task.CompletedTask); + + await this.InvokeRpcAsync( + durabilityProvider.Object, + async client => await client.StartInstanceAsync( + new P.CreateInstanceRequest { Name = "UnknownOrchestrator" }).ResponseAsync); + + durabilityProvider.Verify( + provider => provider.CreateTaskOrchestrationAsync( + It.IsAny(), + It.IsAny(), + It.IsAny()), + Times.Once); + } + + [Fact] + [Trait("Category", PlatformSpecificHelpers.TestCategory)] + public async Task TestGrpcListener_RestartRejectsDisabledOrchestrator() { const string InstanceId = "completed-instance"; const string FunctionName = "DisabledOrchestrator"; - Metadata headers = useCaseVariantTaskHub - ? new Metadata { { TaskHubMetadataKey, "disabledorchestratorrestart" } } - : null; var orchestrationServiceClient = new Mock(); orchestrationServiceClient .Setup(client => client.GetOrchestrationStateAsync(InstanceId, false)) @@ -415,8 +419,7 @@ public async Task TestGrpcListener_RestartRejectsDisabledOrchestrator(bool useCa { InstanceId = InstanceId, RestartWithNewInstanceId = false, - }, - headers).ResponseAsync, + }).ResponseAsync, extension => extension.RegisterOrchestrator( new FunctionName(FunctionName), orchestratorInfo: null)); @@ -1152,6 +1155,26 @@ private async Task InvokeFailingRpcAsync( } } + private async Task InvokeRpcAsync( + DurabilityProvider durabilityProvider, + Func invoke) + { + using DurableTaskExtension extension = this.CreateExtension("TestHub", durabilityProvider); + ILocalGrpcListener listener = LocalGrpcListener.Create(extension, LocalGrpcListenerMode.AspNetCore); + + try + { + await listener.StartAsync(default); + using GrpcChannel channel = GrpcChannel.ForAddress(listener.ListenAddress); + var client = new P.TaskHubSidecarService.TaskHubSidecarServiceClient(channel); + await invoke(client); + } + finally + { + await listener.StopAsync(default); + } + } + private LogMessage AssertWarning(string errorMessage, string methodName, string exceptionType) { LogMessage warning = Assert.Single( @@ -1352,7 +1375,7 @@ private static Mock CreateDurabilityProviderMock( string connectionName = "TestConnection") { var durabilityProvider = new Mock( - "Azure Storage", + "Test", orchestrationService, orchestrationServiceClient, connectionName)