From ed6eb3dc4d1c900d6b109d82264a5057e6d4692e Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Mon, 5 Jan 2026 22:16:35 +0000 Subject: [PATCH 1/5] Initial plan From 36959b8c27f1cafdde03573f5e28201ded5b4ec6 Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Mon, 5 Jan 2026 22:22:42 +0000 Subject: [PATCH 2/5] Improve error message for manual orchestrator and entity function invocation Co-authored-by: YunchuWang <12449837+YunchuWang@users.noreply.github.com> --- .../Bindings/EntityTriggerAttributeBindingProvider.cs | 4 +++- .../Bindings/OrchestrationTriggerAttributeBindingProvider.cs | 4 +++- 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/src/WebJobs.Extensions.DurableTask/Bindings/EntityTriggerAttributeBindingProvider.cs b/src/WebJobs.Extensions.DurableTask/Bindings/EntityTriggerAttributeBindingProvider.cs index 91e6d6a64..3f738a03a 100644 --- a/src/WebJobs.Extensions.DurableTask/Bindings/EntityTriggerAttributeBindingProvider.cs +++ b/src/WebJobs.Extensions.DurableTask/Bindings/EntityTriggerAttributeBindingProvider.cs @@ -141,7 +141,9 @@ public Task BindAsync(object value, ValueBindingContext context) } else { - throw new ArgumentException($"Don't know how to bind to {value?.GetType().Name ?? "null"}.", nameof(value)); + throw new InvalidOperationException( + "Durable entity functions do not support direct invocation. " + + "To interact with an entity, use an HTTP trigger function or the DurableClient binding to call entity methods."); } } diff --git a/src/WebJobs.Extensions.DurableTask/Bindings/OrchestrationTriggerAttributeBindingProvider.cs b/src/WebJobs.Extensions.DurableTask/Bindings/OrchestrationTriggerAttributeBindingProvider.cs index f72bce0bf..9e0cd0991 100644 --- a/src/WebJobs.Extensions.DurableTask/Bindings/OrchestrationTriggerAttributeBindingProvider.cs +++ b/src/WebJobs.Extensions.DurableTask/Bindings/OrchestrationTriggerAttributeBindingProvider.cs @@ -191,7 +191,9 @@ public Task BindAsync(object? value, ValueBindingContext context) } else { - throw new ArgumentException($"Don't know how to bind to {value?.GetType().Name ?? "null"}.", nameof(value)); + throw new InvalidOperationException( + "Durable orchestrator functions do not support direct invocation. " + + "To start an orchestration, use an HTTP trigger function or the DurableClient binding to call 'StartNewAsync'."); } } From 0010b5ca0ac9ea3c7661ac1147f09025c0389d42 Mon Sep 17 00:00:00 2001 From: wangbill Date: Fri, 21 Aug 2026 17:04:44 -0400 Subject: [PATCH 3/5] Refine direct invocation binding errors Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> Copilot-Session: 620c8b07-1ed8-4070-ab0a-83a07d40580a --- .../EntityTriggerAttributeBindingProvider.cs | 8 +- ...strationTriggerAttributeBindingProvider.cs | 8 +- .../Tests/Unit/TriggerBindingProviderTests.cs | 159 ++++++++++++++++++ 3 files changed, 171 insertions(+), 4 deletions(-) create mode 100644 test/FunctionsV2/Tests/Unit/TriggerBindingProviderTests.cs diff --git a/src/WebJobs.Extensions.DurableTask/Bindings/EntityTriggerAttributeBindingProvider.cs b/src/WebJobs.Extensions.DurableTask/Bindings/EntityTriggerAttributeBindingProvider.cs index 9fe91ef86..291ad542f 100644 --- a/src/WebJobs.Extensions.DurableTask/Bindings/EntityTriggerAttributeBindingProvider.cs +++ b/src/WebJobs.Extensions.DurableTask/Bindings/EntityTriggerAttributeBindingProvider.cs @@ -150,12 +150,16 @@ public Task BindAsync(object value, ValueBindingContext context) var triggerData = new TriggerData(contextValueProvider, EmptyBindingData); return Task.FromResult(triggerData); } - else + + // Portal/Admin API invocations use a serialized string trigger value. + else if (value is string) { throw new InvalidOperationException( "Durable entity functions do not support direct invocation. " + - "To interact with an entity, use an HTTP trigger function or the DurableClient binding to call entity methods."); + "Signal an entity from a client or orchestrator function by using a Durable client."); } + + throw new ArgumentException($"Don't know how to bind to {value?.GetType().Name ?? "null"}.", nameof(value)); } public ParameterDescriptor ToParameterDescriptor() diff --git a/src/WebJobs.Extensions.DurableTask/Bindings/OrchestrationTriggerAttributeBindingProvider.cs b/src/WebJobs.Extensions.DurableTask/Bindings/OrchestrationTriggerAttributeBindingProvider.cs index 60f387054..8123087a7 100644 --- a/src/WebJobs.Extensions.DurableTask/Bindings/OrchestrationTriggerAttributeBindingProvider.cs +++ b/src/WebJobs.Extensions.DurableTask/Bindings/OrchestrationTriggerAttributeBindingProvider.cs @@ -198,12 +198,16 @@ public Task BindAsync(object? value, ValueBindingContext context) var triggerData = new TriggerData(contextValueProvider, EmptyBindingData); return Task.FromResult(triggerData); } - else + + // Portal/Admin API invocations use a serialized string trigger value. + else if (value is string) { throw new InvalidOperationException( "Durable orchestrator functions do not support direct invocation. " + - "To start an orchestration, use an HTTP trigger function or the DurableClient binding to call 'StartNewAsync'."); + "Start an orchestration from a client function by using a Durable client."); } + + throw new ArgumentException($"Don't know how to bind to {value?.GetType().Name ?? "null"}.", nameof(value)); } public ParameterDescriptor ToParameterDescriptor() diff --git a/test/FunctionsV2/Tests/Unit/TriggerBindingProviderTests.cs b/test/FunctionsV2/Tests/Unit/TriggerBindingProviderTests.cs new file mode 100644 index 000000000..4883c3c89 --- /dev/null +++ b/test/FunctionsV2/Tests/Unit/TriggerBindingProviderTests.cs @@ -0,0 +1,159 @@ +// Copyright (c) .NET Foundation. All rights reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +#nullable enable + +using System; +using System.Collections.Generic; +using System.Reflection; +using System.Threading; +using System.Threading.Tasks; +using DurableTask.AzureStorage; +using Microsoft.Azure.WebJobs.Host.Triggers; +using Microsoft.Extensions.Logging.Abstractions; +using Microsoft.Extensions.Options; +using Xunit; + +namespace Microsoft.Azure.WebJobs.Extensions.DurableTask.Tests +{ + public class TriggerBindingProviderTests + { + public static IEnumerable UnsupportedTriggerValues() + { + yield return new object?[] { null, "null" }; + yield return new object?[] { 42, "Int32" }; + } + + [Fact] + [Trait("Category", PlatformSpecificHelpers.TestCategory)] + public async Task OrchestrationBinding_StringValue_ThrowsDirectInvocationError() + { + ITriggerBinding binding = await CreateOrchestrationBindingAsync(); + + InvalidOperationException exception = await Assert.ThrowsAsync( + () => binding.BindAsync(string.Empty, context: null!)); + + Assert.Equal( + "Durable orchestrator functions do not support direct invocation. " + + "Start an orchestration from a client function by using a Durable client.", + exception.Message); + } + + [Fact] + [Trait("Category", PlatformSpecificHelpers.TestCategory)] + public async Task EntityBinding_StringValue_ThrowsDirectInvocationError() + { + ITriggerBinding binding = await CreateEntityBindingAsync(); + + InvalidOperationException exception = await Assert.ThrowsAsync( + () => binding.BindAsync(string.Empty, context: null!)); + + Assert.Equal( + "Durable entity functions do not support direct invocation. " + + "Signal an entity from a client or orchestrator function by using a Durable client.", + exception.Message); + } + + [Theory] + [MemberData(nameof(UnsupportedTriggerValues))] + [Trait("Category", PlatformSpecificHelpers.TestCategory)] + public async Task OrchestrationBinding_UnsupportedValue_PreservesTypeDiagnostic( + object? value, + string expectedType) + { + ITriggerBinding binding = await CreateOrchestrationBindingAsync(); + + ArgumentException exception = await Assert.ThrowsAsync( + () => binding.BindAsync(value!, context: null!)); + + Assert.Contains($"Don't know how to bind to {expectedType}.", exception.Message); + Assert.Equal("value", exception.ParamName); + } + + [Theory] + [MemberData(nameof(UnsupportedTriggerValues))] + [Trait("Category", PlatformSpecificHelpers.TestCategory)] + public async Task EntityBinding_UnsupportedValue_PreservesTypeDiagnostic( + object? value, + string expectedType) + { + ITriggerBinding binding = await CreateEntityBindingAsync(); + + ArgumentException exception = await Assert.ThrowsAsync( + () => binding.BindAsync(value!, context: null!)); + + Assert.Contains($"Don't know how to bind to {expectedType}.", exception.Message); + Assert.Equal("value", exception.ParamName); + } + + private static async Task CreateOrchestrationBindingAsync() + { + DurableTaskExtension extension = CreateExtension(); + var provider = new OrchestrationTriggerAttributeBindingProvider( + extension, + connectionName: "AzureWebJobsStorage", + TestHelpers.GetMockPlatformInformationService()); + var context = new TriggerBindingProviderContext( + GetTriggerParameter(nameof(TestOrchestrator)), + CancellationToken.None); + + return await provider.TryCreateAsync(context) + ?? throw new InvalidOperationException("The orchestration trigger binding was not created."); + } + + private static async Task CreateEntityBindingAsync() + { + DurableTaskExtension extension = CreateExtension(); + var provider = new EntityTriggerAttributeBindingProvider(extension, connectionName: "AzureWebJobsStorage"); + var context = new TriggerBindingProviderContext( + GetTriggerParameter(nameof(TestEntity)), + CancellationToken.None); + + return await provider.TryCreateAsync(context) + ?? throw new InvalidOperationException("The entity trigger binding was not created."); + } + + private static ParameterInfo GetTriggerParameter(string methodName) + { + MethodInfo method = typeof(TriggerBindingProviderTests) + .GetMethod(methodName, BindingFlags.NonPublic | BindingFlags.Static) + ?? throw new InvalidOperationException($"The test method '{methodName}' was not found."); + return method.GetParameters()[0]; + } + + private static DurableTaskExtension CreateExtension() + { + var options = new DurableTaskOptions + { + HubName = "TestHub", + WebhookUriProviderOverride = () => new Uri("https://localhost"), + }; + + return new DurableTaskExtension( + new OptionsWrapper(options), + NullLoggerFactory.Instance, + TestHelpers.GetTestNameResolver(), + [ + new AzureStorageDurabilityProviderFactory( + new OptionsWrapper(options), + new TestStorageServiceClientProviderFactory(), + TestHelpers.GetTestNameResolver(), + NullLoggerFactory.Instance, + TestHelpers.GetMockPlatformInformationService()), + ], + new TestHostShutdownNotificationService(), + new DurableHttpMessageHandlerFactory(), + platformInformationService: TestHelpers.GetMockPlatformInformationService()); + } + + private static void TestOrchestrator( + [OrchestrationTrigger] IDurableOrchestrationContext context) + { + } + + private static void TestEntity( + [EntityTrigger] IDurableEntityContext context) + { + } + } +} From 25dc60d890c266d6bd6af9faf84aa8cd31c5b9ad Mon Sep 17 00:00:00 2001 From: wangbill Date: Mon, 24 Aug 2026 19:10:51 -0400 Subject: [PATCH 4/5] Handle omitted Admin API invocation input Treat omitted Admin API input as direct invocation for orchestrator and entity triggers, and cover the real Core Tools endpoint behavior with E2E tests. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> --- .../EntityTriggerAttributeBindingProvider.cs | 6 +- ...strationTriggerAttributeBindingProvider.cs | 4 +- .../Tests/Unit/TriggerBindingProviderTests.cs | 21 ++++--- test/e2e/Tests/Helpers/HttpHelpers.cs | 13 +++++ test/e2e/Tests/Tests/DirectInvocationTests.cs | 55 +++++++++++++++++++ 5 files changed, 87 insertions(+), 12 deletions(-) create mode 100644 test/e2e/Tests/Tests/DirectInvocationTests.cs diff --git a/src/WebJobs.Extensions.DurableTask/Bindings/EntityTriggerAttributeBindingProvider.cs b/src/WebJobs.Extensions.DurableTask/Bindings/EntityTriggerAttributeBindingProvider.cs index 291ad542f..f16c5be69 100644 --- a/src/WebJobs.Extensions.DurableTask/Bindings/EntityTriggerAttributeBindingProvider.cs +++ b/src/WebJobs.Extensions.DurableTask/Bindings/EntityTriggerAttributeBindingProvider.cs @@ -108,7 +108,7 @@ private static IReadOnlyDictionary GetBindingDataContract(Paramete return contract; } - public Task BindAsync(object value, ValueBindingContext context) + public Task BindAsync(object? value, ValueBindingContext context) { if (value is DurableEntityContext entityContext) { @@ -151,8 +151,8 @@ public Task BindAsync(object value, ValueBindingContext context) return Task.FromResult(triggerData); } - // Portal/Admin API invocations use a serialized string trigger value. - else if (value is string) + // Portal/Admin API invocations use null when input is omitted and a serialized string otherwise. + else if (value is null || value is string) { throw new InvalidOperationException( "Durable entity functions do not support direct invocation. " + diff --git a/src/WebJobs.Extensions.DurableTask/Bindings/OrchestrationTriggerAttributeBindingProvider.cs b/src/WebJobs.Extensions.DurableTask/Bindings/OrchestrationTriggerAttributeBindingProvider.cs index 8123087a7..a8c71b4a8 100644 --- a/src/WebJobs.Extensions.DurableTask/Bindings/OrchestrationTriggerAttributeBindingProvider.cs +++ b/src/WebJobs.Extensions.DurableTask/Bindings/OrchestrationTriggerAttributeBindingProvider.cs @@ -199,8 +199,8 @@ public Task BindAsync(object? value, ValueBindingContext context) return Task.FromResult(triggerData); } - // Portal/Admin API invocations use a serialized string trigger value. - else if (value is string) + // Portal/Admin API invocations use null when input is omitted and a serialized string otherwise. + else if (value is null || value is string) { throw new InvalidOperationException( "Durable orchestrator functions do not support direct invocation. " + diff --git a/test/FunctionsV2/Tests/Unit/TriggerBindingProviderTests.cs b/test/FunctionsV2/Tests/Unit/TriggerBindingProviderTests.cs index 4883c3c89..45bb7ca51 100644 --- a/test/FunctionsV2/Tests/Unit/TriggerBindingProviderTests.cs +++ b/test/FunctionsV2/Tests/Unit/TriggerBindingProviderTests.cs @@ -18,20 +18,26 @@ namespace Microsoft.Azure.WebJobs.Extensions.DurableTask.Tests { public class TriggerBindingProviderTests { + public static IEnumerable DirectInvocationTriggerValues() + { + yield return new object?[] { null }; + yield return new object?[] { string.Empty }; + } + public static IEnumerable UnsupportedTriggerValues() { - yield return new object?[] { null, "null" }; yield return new object?[] { 42, "Int32" }; } - [Fact] + [Theory] + [MemberData(nameof(DirectInvocationTriggerValues))] [Trait("Category", PlatformSpecificHelpers.TestCategory)] - public async Task OrchestrationBinding_StringValue_ThrowsDirectInvocationError() + public async Task OrchestrationBinding_DirectInvocationValue_ThrowsDirectInvocationError(object? value) { ITriggerBinding binding = await CreateOrchestrationBindingAsync(); InvalidOperationException exception = await Assert.ThrowsAsync( - () => binding.BindAsync(string.Empty, context: null!)); + () => binding.BindAsync(value!, context: null!)); Assert.Equal( "Durable orchestrator functions do not support direct invocation. " + @@ -39,14 +45,15 @@ public async Task OrchestrationBinding_StringValue_ThrowsDirectInvocationError() exception.Message); } - [Fact] + [Theory] + [MemberData(nameof(DirectInvocationTriggerValues))] [Trait("Category", PlatformSpecificHelpers.TestCategory)] - public async Task EntityBinding_StringValue_ThrowsDirectInvocationError() + public async Task EntityBinding_DirectInvocationValue_ThrowsDirectInvocationError(object? value) { ITriggerBinding binding = await CreateEntityBindingAsync(); InvalidOperationException exception = await Assert.ThrowsAsync( - () => binding.BindAsync(string.Empty, context: null!)); + () => binding.BindAsync(value!, context: null!)); Assert.Equal( "Durable entity functions do not support direct invocation. " + diff --git a/test/e2e/Tests/Helpers/HttpHelpers.cs b/test/e2e/Tests/Helpers/HttpHelpers.cs index 9de59f6ca..c838bb7b7 100644 --- a/test/e2e/Tests/Helpers/HttpHelpers.cs +++ b/test/e2e/Tests/Helpers/HttpHelpers.cs @@ -5,6 +5,7 @@ using System.Net; using System.Net.Http; using System.Net.Http.Headers; +using System.Text; using System.Threading.Tasks; namespace Microsoft.Azure.Durable.Tests.DotnetIsolatedE2E; @@ -28,6 +29,18 @@ public static async Task InvokeHttpTriggerWithBody(string f return await GetResponseMessage(request); } + public static async Task InvokeAdminFunction(string functionName, string body) + { + using HttpRequestMessage request = new() + { + RequestUri = new Uri($"{Constants.FunctionsHostUrl}/admin/functions/{functionName}"), + Method = HttpMethod.Post, + Content = new StringContent(body, Encoding.UTF8, "application/json"), + }; + + return await GetResponseMessage(request); + } + private static HttpRequestMessage GetTestRequest(string functionName, string queryString = "") { return new HttpRequestMessage diff --git a/test/e2e/Tests/Tests/DirectInvocationTests.cs b/test/e2e/Tests/Tests/DirectInvocationTests.cs new file mode 100644 index 000000000..833b9a7c2 --- /dev/null +++ b/test/e2e/Tests/Tests/DirectInvocationTests.cs @@ -0,0 +1,55 @@ +// Copyright (c) .NET Foundation. All rights reserved. +// Licensed under the MIT License. See License.txt in the project root for license information. + +using System.Net; +using Xunit; +using Xunit.Abstractions; + +namespace Microsoft.Azure.Durable.Tests.DotnetIsolatedE2E; + +[Collection(Constants.FunctionAppCollectionName)] +public class DirectInvocationTests +{ + private readonly FunctionAppFixture fixture; + + public DirectInvocationTests(FunctionAppFixture fixture, ITestOutputHelper testOutputHelper) + { + this.fixture = fixture; + this.fixture.TestLogs.UseTestLogger(testOutputHelper); + } + + [Theory] + [InlineData( + "HelloCities", + "{\"input\":\"\"}", + "Durable orchestrator functions do not support direct invocation. Start an orchestration from a client function by using a Durable client.")] + [InlineData( + "HelloCities", + "{}", + "Durable orchestrator functions do not support direct invocation. Start an orchestration from a client function by using a Durable client.")] + [InlineData( + "Counter", + "{\"input\":\"\"}", + "Durable entity functions do not support direct invocation. Signal an entity from a client or orchestrator function by using a Durable client.")] + [InlineData( + "Counter", + "{}", + "Durable entity functions do not support direct invocation. Signal an entity from a client or orchestrator function by using a Durable client.")] + [Trait("PowerShell", "Skip")] + [Trait("Python", "Skip")] + [Trait("Node", "Skip")] + [Trait("Java", "Skip")] + public async Task AdminApiDirectInvocation_LogsActionableGuidance( + string functionName, + string requestBody, + string expectedMessage) + { + using HttpResponseMessage response = await HttpHelpers.InvokeAdminFunction(functionName, requestBody); + + Assert.Equal(HttpStatusCode.Accepted, response.StatusCode); + await this.fixture.TestLogs.AssertLogExistsAsync( + log => log.Contains($"Functions.{functionName}", StringComparison.Ordinal) && + log.Contains(expectedMessage, StringComparison.Ordinal), + $"Expected the direct-invocation guidance for '{functionName}' was not found in the host logs."); + } +} From 39adb3eb0bf61030e1dfba1492236b3b34127084 Mon Sep 17 00:00:00 2001 From: wangbill Date: Tue, 25 Aug 2026 08:55:07 -0400 Subject: [PATCH 5/5] Simplify unsupported trigger diagnostics Remove unreachable null fallbacks after direct invocation values have already been handled. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> Copilot-Session: bbfc6f4b-dec2-4d30-ace8-be903cca5b88 --- .../Bindings/EntityTriggerAttributeBindingProvider.cs | 2 +- .../Bindings/OrchestrationTriggerAttributeBindingProvider.cs | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/WebJobs.Extensions.DurableTask/Bindings/EntityTriggerAttributeBindingProvider.cs b/src/WebJobs.Extensions.DurableTask/Bindings/EntityTriggerAttributeBindingProvider.cs index f16c5be69..0124aa081 100644 --- a/src/WebJobs.Extensions.DurableTask/Bindings/EntityTriggerAttributeBindingProvider.cs +++ b/src/WebJobs.Extensions.DurableTask/Bindings/EntityTriggerAttributeBindingProvider.cs @@ -159,7 +159,7 @@ public Task BindAsync(object? value, ValueBindingContext context) "Signal an entity from a client or orchestrator function by using a Durable client."); } - throw new ArgumentException($"Don't know how to bind to {value?.GetType().Name ?? "null"}.", nameof(value)); + throw new ArgumentException($"Don't know how to bind to {value.GetType().Name}.", nameof(value)); } public ParameterDescriptor ToParameterDescriptor() diff --git a/src/WebJobs.Extensions.DurableTask/Bindings/OrchestrationTriggerAttributeBindingProvider.cs b/src/WebJobs.Extensions.DurableTask/Bindings/OrchestrationTriggerAttributeBindingProvider.cs index a8c71b4a8..c811c2f1e 100644 --- a/src/WebJobs.Extensions.DurableTask/Bindings/OrchestrationTriggerAttributeBindingProvider.cs +++ b/src/WebJobs.Extensions.DurableTask/Bindings/OrchestrationTriggerAttributeBindingProvider.cs @@ -207,7 +207,7 @@ public Task BindAsync(object? value, ValueBindingContext context) "Start an orchestration from a client function by using a Durable client."); } - throw new ArgumentException($"Don't know how to bind to {value?.GetType().Name ?? "null"}.", nameof(value)); + throw new ArgumentException($"Don't know how to bind to {value.GetType().Name}.", nameof(value)); } public ParameterDescriptor ToParameterDescriptor()