Isolate background workflow dispatches from caller's cancellation token

src/modules/Elsa.Workflows.Runtime/Services/BackgroundWorkflowDispatcher.cs

@@ -30,7 +30,8 @@ public async Task<DispatchWorkflowResponse> DispatchAsync(DispatchWorkflowDefini
             ParentWorkflowInstanceId = request.ParentWorkflowInstanceId,
         };
 
-        await commandSender.SendAsync(command, CommandStrategy.Background, CreateHeaders(), cancellationToken);
+        // Background commands run independently of caller's lifecycle.
+        await commandSender.SendAsync(command, CommandStrategy.Background, CreateHeaders(), CancellationToken.None);
         var response = DispatchWorkflowResponse.Success();
 
         // Emit dispatched notification
@@ -52,7 +53,8 @@ public async Task<DispatchWorkflowResponse> DispatchAsync(DispatchWorkflowInstan
             Properties = request.Properties,
             CorrelationId = request.CorrelationId};
 
-        await commandSender.SendAsync(command, CommandStrategy.Background, CreateHeaders(), cancellationToken);
+        // Background commands run independently of caller's lifecycle.
+        await commandSender.SendAsync(command, CommandStrategy.Background, CreateHeaders(), CancellationToken.None);
         var response = DispatchWorkflowResponse.Success();
 
         // Emit dispatched notification
@@ -72,7 +74,9 @@ public async Task<DispatchWorkflowResponse> DispatchAsync(DispatchTriggerWorkflo
             Input = request.Input,
             Properties = request.Properties
         };
-        await commandSender.SendAsync(command, CommandStrategy.Background, CreateHeaders(), cancellationToken);
+
+        // Background commands run independently of caller's lifecycle.
+        await commandSender.SendAsync(command, CommandStrategy.Background, CreateHeaders(), CancellationToken.None);
         return DispatchWorkflowResponse.Success();
     }
 
@@ -86,7 +90,9 @@ public async Task<DispatchWorkflowResponse> DispatchAsync(DispatchResumeWorkflow
             ActivityInstanceId = request.ActivityInstanceId,
             Input = request.Input
         };
-        await commandSender.SendAsync(command, CommandStrategy.Background, CreateHeaders(), cancellationToken);
+
+        // Background commands run independently of caller's lifecycle.
+        await commandSender.SendAsync(command, CommandStrategy.Background, CreateHeaders(), CancellationToken.None);
         return DispatchWorkflowResponse.Success();
     }
 

test/unit/Elsa.Workflows.Runtime.UnitTests/Services/BackgroundWorkflowDispatcherTests.cs

@@ -0,0 +1,96 @@
+using Elsa.Common.Multitenancy;
+using Elsa.Mediator;
+using Elsa.Mediator.Contracts;
+using Elsa.Workflows.Runtime.Commands;
+using Elsa.Workflows.Runtime.Requests;
+using NSubstitute;
+
+namespace Elsa.Workflows.Runtime.UnitTests.Services;
+
+public class BackgroundWorkflowDispatcherTests
+{
+    private readonly ICommandSender _commandSender = Substitute.For<ICommandSender>();
+    private readonly INotificationSender _notificationSender = Substitute.For<INotificationSender>();
+    private readonly ITenantAccessor _tenantAccessor = Substitute.For<ITenantAccessor>();
+
+    [Fact]
+    public async Task DispatchWorkflowDefinition_DoesNotPropagateCallerToken()
+    {
+        // Arrange
+        var dispatcher = CreateDispatcher();
+        var request = new DispatchWorkflowDefinitionRequest("test-definition-id");
+        using var callerCts = new CancellationTokenSource();
+
+        // Act
+        await dispatcher.DispatchAsync(request, cancellationToken: callerCts.Token);
+
+        // Assert
+        await _commandSender.Received(1).SendAsync(
+            Arg.Any<DispatchWorkflowDefinitionCommand>(),
+            CommandStrategy.Background,
+            Arg.Any<IDictionary<object, object>>(),
+            CancellationToken.None);
+    }
+
+    [Fact]
+    public async Task DispatchWorkflowInstance_DoesNotPropagateCallerToken()
+    {
+        // Arrange
+        var dispatcher = CreateDispatcher();
+        var request = new DispatchWorkflowInstanceRequest("test-instance-id");
+        using var callerCts = new CancellationTokenSource();
+
+        // Act
+        await dispatcher.DispatchAsync(request, cancellationToken: callerCts.Token);
+
+        // Assert
+        await _commandSender.Received(1).SendAsync(
+            Arg.Any<DispatchWorkflowInstanceCommand>(),
+            CommandStrategy.Background,
+            Arg.Any<IDictionary<object, object>>(),
+            CancellationToken.None);
+    }
+
+    [Fact]
+    public async Task DispatchTriggerWorkflows_DoesNotPropagateCallerToken()
+    {
+        // Arrange
+        var dispatcher = CreateDispatcher();
+        var request = new DispatchTriggerWorkflowsRequest("TestActivityType", new { });
+        using var callerCts = new CancellationTokenSource();
+
+        // Act
+        await dispatcher.DispatchAsync(request, cancellationToken: callerCts.Token);
+
+        // Assert
+        await _commandSender.Received(1).SendAsync(
+            Arg.Any<DispatchTriggerWorkflowsCommand>(),
+            CommandStrategy.Background,
+            Arg.Any<IDictionary<object, object>>(),
+            CancellationToken.None);
+    }
+
+    [Fact]
+    public async Task DispatchResumeWorkflows_DoesNotPropagateCallerToken()
+    {
+        // Arrange
+        var dispatcher = CreateDispatcher();
+        var request = new DispatchResumeWorkflowsRequest("TestActivityType", new { });
+        using var callerCts = new CancellationTokenSource();
+
+        // Act
+        await dispatcher.DispatchAsync(request, cancellationToken: callerCts.Token);
+
+        // Assert
+        await _commandSender.Received(1).SendAsync(
+            Arg.Any<DispatchResumeWorkflowsCommand>(),
+            CommandStrategy.Background,
+            Arg.Any<IDictionary<object, object>>(),
+            CancellationToken.None);
+    }
+
+    private BackgroundWorkflowDispatcher CreateDispatcher()
+    {
+        return new(_commandSender, _notificationSender, _tenantAccessor);
+    }
+}