Add IBeforeStep and IAfterStep hooks

Author: Romfos

src/BddDotNet.Tests/Core/AfterStepTests.cs

@@ -0,0 +1,48 @@
+using BddDotNet.Extensibility;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace BddDotNet.Tests.Core;
+
+[TestClass]
+public sealed class AfterStepTests
+{
+    [TestMethod]
+    public async Task AfterStepTest()
+    {
+        var traces = new List<string>();
+
+        await TestPlatform.RunTestAsync(services =>
+        {
+            services.AddSingleton(traces);
+
+            services.Scenario<ScenarioAndStepTests>("feature1", "scenario1", async context =>
+            {
+                await context.Then("then1");
+                await context.Then("then2");
+            });
+
+            services.Then(new("then1"), () =>
+            {
+                traces.Add("1");
+            });
+
+            services.Then(new("then2"), () =>
+            {
+                throw new Exception("2");
+            });
+
+            services.AfterStep<AfterStep1>();
+        });
+
+        Assert.IsTrue(traces is ["1", "AfterStep null", "AfterStep 2"]);
+    }
+}
+
+file sealed class AfterStep1(List<string> traces) : IAfterStep
+{
+    public Task AfterStep(Exception? exception)
+    {
+        traces.Add($"AfterStep {exception?.Message ?? "null"}");
+        return Task.CompletedTask;
+    }
+}

src/BddDotNet.Tests/Core/BeforeStepTests.cs

@@ -0,0 +1,42 @@
+using BddDotNet.Extensibility;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace BddDotNet.Tests.Core;
+
+[TestClass]
+public sealed class BeforeStepTests
+{
+    [TestMethod]
+    public async Task BeforeStepTest()
+    {
+        var traces = new List<string>();
+
+        await TestPlatform.RunTestAsync(services =>
+        {
+            services.AddSingleton(traces);
+
+            services.Scenario<ScenarioAndStepTests>("feature1", "scenario1", async context =>
+            {
+                await context.Then("then1");
+            });
+
+            services.Then(new("then1"), () =>
+            {
+                traces.Add("1");
+            });
+
+            services.BeforeStep<BeforeStep1>();
+        });
+
+        Assert.IsTrue(traces is ["BeforeStep", "1"]);
+    }
+}
+
+file sealed class BeforeStep1(List<string> traces) : IBeforeStep
+{
+    public Task BeforeStep()
+    {
+        traces.Add("BeforeStep");
+        return Task.CompletedTask;
+    }
+}

src/BddDotNet/Extensibility.cs

@@ -32,5 +32,21 @@ public static partial class ServiceCollectionExtensions
             serviceCollection.AddScoped<IArgumentTransformation>(services => services.GetRequiredService<T>());
             return serviceCollection;
         }
+
+        public IServiceCollection BeforeStep<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] T>()
+            where T : class, IBeforeStep
+        {
+            serviceCollection.TryAddScoped<T>();
+            serviceCollection.AddScoped<IBeforeStep>(services => services.GetRequiredService<T>());
+            return serviceCollection;
+        }
+
+        public IServiceCollection AfterStep<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] T>()
+            where T : class, IAfterStep
+        {
+            serviceCollection.TryAddScoped<T>();
+            serviceCollection.AddScoped<IAfterStep>(services => services.GetRequiredService<T>());
+            return serviceCollection;
+        }
     }
 }

src/BddDotNet/Extensibility/IAfterStep.cs

@@ -0,0 +1,6 @@
+namespace BddDotNet.Extensibility;
+
+public interface IAfterStep
+{
+    Task AfterStep(Exception? exception);
+}

src/BddDotNet/Extensibility/IBeforeStep.cs

@@ -0,0 +1,6 @@
+namespace BddDotNet.Extensibility;
+
+public interface IBeforeStep
+{
+    Task BeforeStep();
+}

src/BddDotNet/Internal/Services/StepExecutionService.cs

@@ -9,9 +9,46 @@ namespace BddDotNet.Internal.Services;
 internal sealed class StepExecutionService(
     IServiceProvider serviceProvider,
     IEnumerable<Step> steps,
-    IEnumerable<IArgumentTransformation> argumentTransformations)
+    IEnumerable<IArgumentTransformation> argumentTransformations,
+    IEnumerable<IBeforeStep> beforeStepHooks,
+    IEnumerable<IAfterStep> afterStepHook)
 {
     public async Task ExecuteAsync(StepType stepType, string text, object?[] additionalStepArguments)
+    {
+        var keyword = stepType.ToString();
+
+        await BeforeStep();
+
+        try
+        {
+            await FindAndExecuteStepAsync(stepType, text, additionalStepArguments);
+        }
+        catch (Exception exception)
+        {
+            await AfterStep(exception.GetBaseException());
+            throw;
+        }
+
+        await AfterStep(null);
+    }
+
+    private async Task BeforeStep()
+    {
+        foreach (var beforeStepHook in beforeStepHooks)
+        {
+            await beforeStepHook.BeforeStep();
+        }
+    }
+
+    private async Task AfterStep(Exception? exception)
+    {
+        foreach (var afterStepHook in afterStepHook.Reverse())
+        {
+            await afterStepHook.AfterStep(exception);
+        }
+    }
+
+    private async Task FindAndExecuteStepAsync(StepType stepType, string text, object?[] additionalStepArguments)
     {
         var (step, match) = FindGherkinStep(stepType, text);