test: Add new tests for pipeline execution behaviors and diagnostics handling

Author: vp

tests/Common.UnitTests/Utilities/Pipeline/PipelineExecutionTests.cs

@@ -57,6 +57,47 @@ public async Task ExecuteAsync_ThrownStepException_ReturnsFailedResultWithExcept
         result.Messages.ShouldContain("boom");
     }
 
+    [Fact]
+    public async Task ExecuteAsync_FailedResult_DefaultStopsRemainingSteps()
+    {
+        var services = CreateServices();
+        services.AddPipelines()
+            .WithPipeline<ContinueOnFailurePipeline>();
+
+        var provider = services.BuildServiceProvider();
+        var pipeline = provider.GetRequiredService<IPipelineFactory>()
+            .Create<ContinueOnFailurePipeline, TestContext>();
+        var context = new TestContext();
+
+        var result = await pipeline.ExecuteAsync(context);
+
+        result.IsFailure.ShouldBeTrue();
+        result.Messages.ShouldContain("failed-step");
+        context.AfterFailureExecuted.ShouldBeFalse();
+        context.Pipeline.ExecutedStepCount.ShouldBe(1);
+    }
+
+    [Fact]
+    public async Task ExecuteAsync_FailedResult_WhenContinueOnFailure_ContinuesRemainingSteps()
+    {
+        var services = CreateServices();
+        services.AddPipelines()
+            .WithPipeline<ContinueOnFailurePipeline>();
+
+        var provider = services.BuildServiceProvider();
+        var pipeline = provider.GetRequiredService<IPipelineFactory>()
+            .Create<ContinueOnFailurePipeline, TestContext>();
+        var context = new TestContext();
+
+        var result = await pipeline.ExecuteAsync(context, builder => builder.ContinueOnFailure());
+
+        result.IsFailure.ShouldBeTrue();
+        result.Messages.ShouldContain("failed-step");
+        result.Messages.ShouldContain("after-failure");
+        context.AfterFailureExecuted.ShouldBeTrue();
+        context.Pipeline.ExecutedStepCount.ShouldBe(2);
+    }
+
     [Fact]
     public async Task ExecuteAsync_Retry_ReexecutesStepUntilSuccess()
     {
@@ -78,6 +119,26 @@ public async Task ExecuteAsync_Retry_ReexecutesStepUntilSuccess()
         context.Pipeline.ExecutedStepCount.ShouldBe(2);
     }
 
+    [Fact]
+    public async Task ExecuteAsync_RetryExhaustion_ReturnsFailedResultWithRetryError()
+    {
+        var services = CreateServices();
+        services.AddPipelines()
+            .WithPipeline<RetryExhaustionPipeline>();
+
+        var provider = services.BuildServiceProvider();
+        var pipeline = provider.GetRequiredService<IPipelineFactory>()
+            .Create<RetryExhaustionPipeline, TestContext>();
+        var context = new TestContext();
+
+        var result = await pipeline.ExecuteAsync(context, builder => builder.MaxRetryAttemptsPerStep(2));
+
+        result.IsFailure.ShouldBeTrue();
+        result.Errors.OfType<Error>().Any(e => e.Message.Contains("exhausted retry attempts")).ShouldBeTrue();
+        context.RetryAttempts.ShouldBe(3);
+        context.Pipeline.ExecutedStepCount.ShouldBe(3);
+    }
+
     [Fact]
     public async Task ExecuteAsync_Break_StopsRemainingSteps()
     {
@@ -97,6 +158,46 @@ public async Task ExecuteAsync_Break_StopsRemainingSteps()
         context.Pipeline.ExecutedStepCount.ShouldBe(2);
     }
 
+    [Fact]
+    public async Task ExecuteAsync_AccumulateDiagnosticsOnFailureFalse_StripsFailureDiagnostics()
+    {
+        var services = CreateServices();
+        services.AddPipelines()
+            .WithPipeline<ContinueOnFailurePipeline>();
+
+        var provider = services.BuildServiceProvider();
+        var pipeline = provider.GetRequiredService<IPipelineFactory>()
+            .Create<ContinueOnFailurePipeline, TestContext>();
+
+        var result = await pipeline.ExecuteAsync(
+            new TestContext(),
+            builder => builder.AccumulateDiagnosticsOnFailure(false));
+
+        result.IsFailure.ShouldBeTrue();
+        result.Messages.ShouldBeEmpty();
+        result.Errors.ShouldBeEmpty();
+    }
+
+    [Fact]
+    public async Task ExecuteAsync_AccumulateDiagnosticsOnBreakFalse_StripsBreakDiagnostics()
+    {
+        var services = CreateServices();
+        services.AddPipelines()
+            .WithPipeline<BreakDiagnosticsPipeline>();
+
+        var provider = services.BuildServiceProvider();
+        var pipeline = provider.GetRequiredService<IPipelineFactory>()
+            .Create<BreakDiagnosticsPipeline, TestContext>();
+
+        var result = await pipeline.ExecuteAsync(
+            new TestContext(),
+            builder => builder.AccumulateDiagnosticsOnBreak(false));
+
+        result.IsSuccess.ShouldBeTrue();
+        result.Messages.ShouldBeEmpty();
+        result.Errors.ShouldBeEmpty();
+    }
+
     [Fact]
     public async Task ExecuteAsync_InlineSteps_WorkForSyncAsyncAndContextAwareDelegates()
     {
@@ -134,6 +235,40 @@ public async Task ExecuteAsync_InlineSteps_WorkForSyncAsyncAndContextAwareDelega
         context.Pipeline.ExecutedStepCount.ShouldBe(5);
     }
 
+    [Fact]
+    public async Task ExecuteAsync_ProgressReporter_IsExposedToClassAndInlineSteps()
+    {
+        var services = CreateServices();
+        var progress = new RecordingProgress();
+
+        services.AddPipelines()
+            .WithPipeline<TestContext>("progress", builder => builder
+                .AddStep<ProgressStep>()
+                .AddStep(execution =>
+                {
+                    execution.Options.Progress?.Report(new ProgressReport(
+                        execution.Name,
+                        ["inline-progress"],
+                        100,
+                        isCompleted: true));
+
+                    return execution.Continue();
+                }));
+
+        var provider = services.BuildServiceProvider();
+        var pipeline = provider.GetRequiredService<IPipelineFactory>()
+            .Create<TestContext>("progress");
+
+        var result = await pipeline.ExecuteAsync(
+            new TestContext(),
+            builder => builder.WithProgress(progress));
+
+        result.IsSuccess.ShouldBeTrue();
+        progress.Reports.Count.ShouldBe(2);
+        progress.Reports[0].Messages.ShouldContain("class-progress");
+        progress.Reports[1].Messages.ShouldContain("inline-progress");
+    }
+
     [Fact]
     public async Task ExecuteAsync_BaseContextHookAndBehavior_AreAppliedToDerivedContextPipeline()
     {
@@ -204,6 +339,51 @@ public async Task ExecuteAndForgetAsync_TracksExecutionAndInvokesCompletionCallb
         completion.Status.ShouldBe(PipelineExecutionStatus.Completed);
     }
 
+    [Fact]
+    public async Task ExecuteAndForgetAsync_CompletionCallbackFailure_DoesNotOverwriteCompletedSnapshot()
+    {
+        var services = CreateServices();
+        services.AddPipelines()
+            .WithPipeline<BackgroundPipeline>();
+
+        var provider = services.BuildServiceProvider();
+        var factory = provider.GetRequiredService<IPipelineFactory>();
+        var tracker = provider.GetRequiredService<IPipelineExecutionTracker>();
+        var pipeline = factory.Create<BackgroundPipeline, TestContext>();
+        var callbackSource = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+        PipelineExecutionSnapshot snapshotObservedInCallback = null;
+
+        var handle = await pipeline.ExecuteAndForgetAsync(
+            new TestContext(),
+            builder => builder.WhenCompleted(async completion =>
+            {
+                snapshotObservedInCallback = await tracker.GetAsync(completion.ExecutionId);
+                callbackSource.TrySetResult();
+                throw new InvalidOperationException("callback boom");
+            }));
+
+        await callbackSource.Task.WaitAsync(TimeSpan.FromSeconds(5));
+
+        PipelineExecutionSnapshot snapshot = null;
+        for (var i = 0; i < 40; i++)
+        {
+            snapshot = await tracker.GetAsync(handle.ExecutionId);
+            if (snapshot?.Status == PipelineExecutionStatus.Completed)
+            {
+                break;
+            }
+
+            await Task.Delay(25);
+        }
+
+        snapshot.ShouldNotBeNull();
+        snapshot.Status.ShouldBe(PipelineExecutionStatus.Completed);
+        snapshot.Result.IsSuccess.ShouldBeTrue();
+        snapshotObservedInCallback.ShouldNotBeNull();
+        snapshotObservedInCallback.Status.ShouldBe(PipelineExecutionStatus.Completed);
+        snapshotObservedInCallback.Result.IsSuccess.ShouldBeTrue();
+    }
+
     [Fact]
     public async Task ExecuteAsync_TracingBehavior_CreatesPipelineAndStepActivities()
     {
@@ -251,6 +431,8 @@ public sealed class TestContext : PipelineContextBase
 
         public bool AfterBreakExecuted { get; set; }
 
+        public bool AfterFailureExecuted { get; set; }
+
         public int ContextStepCount { get; set; }
     }
 
@@ -289,6 +471,32 @@ protected override void Configure(IPipelineDefinitionBuilder<TestContext> builde
         }
     }
 
+    public sealed class ContinueOnFailurePipeline : PipelineDefinition<TestContext>
+    {
+        protected override void Configure(IPipelineDefinitionBuilder<TestContext> builder)
+        {
+            builder.AddStep<FailedResultStep>()
+                .AddStep<AfterFailureStep>();
+        }
+    }
+
+    public sealed class RetryExhaustionPipeline : PipelineDefinition<TestContext>
+    {
+        protected override void Configure(IPipelineDefinitionBuilder<TestContext> builder)
+        {
+            builder.AddStep<AlwaysRetryStep>();
+        }
+    }
+
+    public sealed class BreakDiagnosticsPipeline : PipelineDefinition<TestContext>
+    {
+        protected override void Configure(IPipelineDefinitionBuilder<TestContext> builder)
+        {
+            builder.AddStep<BreakWithDiagnosticsStep>()
+                .AddStep<AfterBreakStep>();
+        }
+    }
+
     public sealed class BackgroundPipeline : PipelineDefinition<TestContext>
     {
         protected override void Configure(IPipelineDefinitionBuilder<TestContext> builder)
@@ -322,6 +530,26 @@ protected override PipelineControl Execute(TestContext context, Result result, P
         }
     }
 
+    public sealed class FailedResultStep : PipelineStep<TestContext>
+    {
+        protected override PipelineControl Execute(TestContext context, Result result, PipelineExecutionOptions options)
+        {
+            return PipelineControl.Continue(
+                Result.Failure()
+                    .WithMessage("failed-step")
+                    .WithError(new Error("failed-error")));
+        }
+    }
+
+    public sealed class AfterFailureStep : PipelineStep<TestContext>
+    {
+        protected override PipelineControl Execute(TestContext context, Result result, PipelineExecutionOptions options)
+        {
+            context.AfterFailureExecuted = true;
+            return PipelineControl.Continue(result.WithMessage("after-failure"));
+        }
+    }
+
     public sealed class RetryStep : PipelineStep<TestContext>
     {
         protected override PipelineControl Execute(TestContext context, Result result, PipelineExecutionOptions options)
@@ -333,6 +561,15 @@ protected override PipelineControl Execute(TestContext context, Result result, P
         }
     }
 
+    public sealed class AlwaysRetryStep : PipelineStep<TestContext>
+    {
+        protected override PipelineControl Execute(TestContext context, Result result, PipelineExecutionOptions options)
+        {
+            context.RetryAttempts++;
+            return PipelineControl.Retry(result.WithMessage($"retry-{context.RetryAttempts}"), "retry");
+        }
+    }
+
     public sealed class BreakStep : PipelineStep<TestContext>
     {
         protected override PipelineControl Execute(TestContext context, Result result, PipelineExecutionOptions options)
@@ -341,6 +578,14 @@ protected override PipelineControl Execute(TestContext context, Result result, P
         }
     }
 
+    public sealed class BreakWithDiagnosticsStep : PipelineStep<TestContext>
+    {
+        protected override PipelineControl Execute(TestContext context, Result result, PipelineExecutionOptions options)
+        {
+            return PipelineControl.Break(result.WithMessage("break-diagnostic"), "break");
+        }
+    }
+
     public sealed class AfterBreakStep : PipelineStep<TestContext>
     {
         protected override PipelineControl Execute(TestContext context, Result result, PipelineExecutionOptions options)
@@ -350,6 +595,15 @@ protected override PipelineControl Execute(TestContext context, Result result, P
         }
     }
 
+    public sealed class ProgressStep : PipelineStep<TestContext>
+    {
+        protected override PipelineControl Execute(TestContext context, Result result, PipelineExecutionOptions options)
+        {
+            options.Progress?.Report(new ProgressReport(this.Name, ["class-progress"], 50));
+            return PipelineControl.Continue(result);
+        }
+    }
+
     public sealed class BackgroundStep : AsyncPipelineStep<TestContext>
     {
         protected override async ValueTask<PipelineControl> ExecuteAsync(TestContext context, Result result, PipelineExecutionOptions options, CancellationToken cancellationToken)
@@ -370,6 +624,16 @@ public sealed class ExecutionProbe
         public int StepBehaviorCount { get; set; }
     }
 
+    public sealed class RecordingProgress : IProgress<ProgressReport>
+    {
+        public List<ProgressReport> Reports { get; } = [];
+
+        public void Report(ProgressReport value)
+        {
+            this.Reports.Add(value);
+        }
+    }
+
     public sealed class ProbeHook(ExecutionProbe probe) : PipelineHook<PipelineContextBase>
     {
         public override ValueTask OnPipelineStartingAsync(PipelineContextBase context, CancellationToken cancellationToken)