[FIX] cannot end a flowchart when a End is Then Activity in If

src/modules/Elsa.Workflows.Core/Activities/Break.cs

@@ -25,4 +25,4 @@ protected override async ValueTask ExecuteAsync(ActivityExecutionContext context
         // Send a signal to the parent scope to break out of the loop.
         await context.SendSignalAsync(new BreakSignal());
     }
-}
+}

src/modules/Elsa.Workflows.Core/Activities/End.cs

@@ -16,4 +16,9 @@ public class End : CodeActivity, ITerminalNode
     public End([CallerFilePath] string? source = default, [CallerLineNumber] int? line = default) : base(source, line)
     {
     }
-}
+
+    protected async override ValueTask ExecuteAsync(ActivityExecutionContext context)
+    {
+        await context.SendSignalAsync(new EndSignal());
+    }
+}

src/modules/Elsa.Workflows.Core/Activities/Flowchart/Activities/Flowchart.cs

@@ -27,6 +27,9 @@ public Flowchart([CallerFilePath] string? source = default, [CallerLineNumber] i
         OnSignalReceived<ScheduleActivityOutcomes>(OnScheduleOutcomesAsync);
         OnSignalReceived<ScheduleChildActivity>(OnScheduleChildActivityAsync);
         OnSignalReceived<CancelSignal>(OnActivityCanceledAsync);
+
+        OnSignalReceived<BreakSignal>(OnBreakSignalReceived);
+        OnSignalReceived<EndSignal>(OnEndSignalReceived);
     }
 
     /// <summary>
@@ -144,6 +147,14 @@ private async ValueTask OnChildCompletedAsync(ActivityCompletedContext context)
         var completedActivity = completedActivityContext.Activity;
         var result = context.Result;
 
+        bool isBreaking = flowchartContext.GetIsBreaking();
+        bool isEnding = flowchartContext.GetIsEnding();
+        if (isBreaking || isEnding) 
+        {
+            await flowchartContext.CompleteActivityAsync();
+            return;
+        }
+
         // If the complete activity's status is anything but "Completed", do not schedule its outbound activities.
         var scheduleChildren = completedActivityContext.Status == ActivityStatus.Completed;
         var outcomeNames = result is Outcomes outcomes
@@ -286,4 +297,16 @@ private async ValueTask OnActivityCanceledAsync(CancelSignal signal, SignalConte
     {
         await CompleteIfNoPendingWorkAsync(context.ReceiverActivityExecutionContext);
     }
-}
+
+    private void OnBreakSignalReceived(BreakSignal signal, SignalContext context)
+    {
+        context.ReceiverActivityExecutionContext.SetIsBreaking();
+    }
+
+    private void OnEndSignalReceived(EndSignal signal, SignalContext context)
+    {
+        // Prevent bubbling.
+        context.StopPropagation();
+        context.ReceiverActivityExecutionContext.SetIsEnding();
+    }
+}

src/modules/Elsa.Workflows.Core/Extensions/EndSignalActivityExecutionContextExtensions.cs

@@ -0,0 +1,14 @@
+namespace Elsa.Workflows.Extensions;
+
+public static class EndSignalActivityExecutionContextExtensions
+{
+  /// <summary>
+  /// Gets a value indicating whether the current activity is ending out of a flowchart.
+  /// </summary>
+  public static bool GetIsEnding(this ActivityExecutionContext context) => context.GetProperty<bool>("IsEnding");
+
+  /// <summary>
+  /// Sets a value indicating whether the current activity is ending out of a flowchart.
+  /// <summary>
+  public static void SetIsEnding(this ActivityExecutionContext context) => context.SetProperty("IsEnding", true);
+}

src/modules/Elsa.Workflows.Core/Signals/EndSignal.cs

@@ -0,0 +1,3 @@
+namespace Elsa.Workflows.Signals;
+
+public record EndSignal;

test/integration/Elsa.Workflows.IntegrationTests/Activities/Break/BreakTests.cs

@@ -62,4 +62,13 @@ public async Task Test5()
         var lines = _capturingTextWriter.Lines.ToList();
         Assert.Equal(new[] { "Start", "1", "2", "End" }, lines);
     }
-}
+
+    [Fact(DisplayName = "Break While whin a Flowchart")]
+    public async Task Test6()
+    {
+        await _services.PopulateRegistriesAsync();
+        await _workflowRunner.RunAsync<BreakWhileFlowchartWorkflow>();
+        var lines = _capturingTextWriter.Lines.ToList();
+        Assert.Equal(new[] { "start" }, lines);
+    }
+}

test/integration/Elsa.Workflows.IntegrationTests/Activities/Break/Workflows/BreakWhileFlowchartWorkflow.cs

@@ -0,0 +1,31 @@
+using Elsa.Workflows.Activities.Flowchart.Models;
+using Elsa.Workflows.Activities;
+using Elsa.Workflows.Activities.Flowchart.Activities;
+using Elsa.Workflows.Contracts;
+
+namespaces Elsa.Workflows.IntegrationTests.Activities.Workflows;
+public class BreakWhileFlowchart : WorkflowBase
+{
+    protected override void Build(IWorkflowBuilder workflow)
+    {
+        WtiteLine start = new("start");
+        WriteLine end = new("end");
+        If condition = new If(c => true) 
+        {
+            Then = new Break()
+        };
+
+        workflow.Root = While.True(new Flowchart()
+        {
+            Activities = 
+            {
+                start, condition, end
+            },
+            Connections = 
+            {
+                new Connection(start, condition),
+                new Connection(condition, end),
+            }
+        });
+    }
+}

test/integration/Elsa.Workflows.IntegrationTests/Activities/End/EndFlowchartWorkflow.cs

@@ -0,0 +1,29 @@
+using Elsa.Workflows.Activities.Flowchart.Models;
+using Elsa.Workflows.Activities;
+using Elsa.Workflows.Activities.Flowchart.Activities;
+using Elsa.Workflows.Contracts;
+
+namespace Elsa.Workflows.IntegrationTests.Activities.Workflows;
+public class EndFlowchartWorkflow : WorkflowBase
+{
+    protected override void Build(IWorkflowBuilder workflow) 
+    {
+        WriteLine start = new("start");
+        WriteLine end = new("end");
+        If condition = new(c => true)
+        {
+            Then = new End()
+        };
+
+        workflow.Root = new Flowchart()
+        {
+            Activities = {
+                start, condition, end
+            },
+            Connections = {
+                new Connection(start, condition),
+                new Connection(condition, end),
+            }
+        };
+    }
+}

test/integration/Elsa.Workflows.IntegrationTests/Activities/End/EndTests.cs

@@ -0,0 +1,29 @@
+using Elsa.Testing.Shared;
+using Elsa.Workflows.Contracts;
+using Elsa.Workflows.IntegrationTests.Activities.Workflows;
+using Microsoft.Extensions.DependencyInjection;
+using Xunit;
+using Xunit.Abstraction;
+
+namespace Elsa.Workflows.IntegrationTests,Activities;
+public class EndTests
+{
+    private readonly IWorkflowRunner _workflowRunner;
+    private readonly CapturingTextWriter _capturingTextWriter = new();
+    private readonly IServiceProvider _services;
+
+    public EndTests(ITestOutputHelper testOutputHelper)
+    {
+        _services = new TestApplicationBuilder(testOutputHelper).WithCapturingTextWriter(_capturingTextWriter).Build();
+        _workflowRunner = _services.GetRequiredService<IWorkflowRunner>();
+    }
+
+    [Fact(DisplayName = "End a flowchart when the End is nested in If")]
+    public async Task Test1()
+    {
+        await _services.PopulateRegistriesAsync();
+        await _workflowRunner.RunAsync<EndFlowchartWorkflow>();
+        var lines = _capturingTextWriter.Lines.ToList();
+        Assert.Equal(new[] { "start" }, lines);
+    }
+}