Feature generate async snippets from 'DefineSteps' command (#129)

clrudolphi · gasparnagy · web-flow · commit 30f1ce5e3486 · 2025-12-17T16:41:04.000+01:00
* Snippet generator honors the StepDefinitionSkeletonStyle setting from the reqnroll.json file when generating snippets (sync or async).
Added unit tests for the new skeletonStyle enum deserialization.
Added unit test for the SnippetService.
Added Spec test in the DefineStepsCommand spec for the generation of async and sync snippets.

* Updated Changelog

* Add PR number to CHANGELOG

---------

Co-authored-by: Gáspár Nagy &lt;gaspar.nagy@gmail.com&gt;
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -4,6 +4,7 @@
 
 ## Improvements:
 
+* The 'Define Steps' command honors the StepDefinitionSkeletonStyle setting in the project reqnroll.json configuration file and will generate step skeletons using 'Async' appropriately. (#129)
 * Update docs - .NET 10, TUnit, VS2026 (#138)
 
 ## Bug fixes:
diff --git a/Reqnroll.VisualStudio/Configuration/ReqnrollConfigDeserializer.cs b/Reqnroll.VisualStudio/Configuration/ReqnrollConfigDeserializer.cs
@@ -21,10 +21,14 @@ public void Populate(string jsonString, DeveroomConfiguration config)
             config.ConfiguredBindingCulture = bindingCulture;
         if (reqnrollJsonConfiguration.Trace != null &&
             reqnrollJsonConfiguration.Trace.TryGetValue("stepDefinitionSkeletonStyle", out var sdSnippetStyle)) {
-            if (sdSnippetStyle == "CucumberExpressionAttribute")
-                config.SnippetExpressionStyle = SnippetExpressionStyle.CucumberExpression;
-            if (sdSnippetStyle == "RegexAttribute")
-                config.SnippetExpressionStyle = SnippetExpressionStyle.RegularExpression;
+            config.SnippetExpressionStyle = sdSnippetStyle switch
+            {
+                "CucumberExpressionAttribute" => SnippetExpressionStyle.CucumberExpression,
+                "RegexAttribute" => SnippetExpressionStyle.RegularExpression,
+                "AsyncCucumberExpressionAttribute" => SnippetExpressionStyle.AsyncCucumberExpression,
+                "AsyncRegexAttribute" => SnippetExpressionStyle.AsyncRegularExpression,
+                _ => SnippetExpressionStyle.CucumberExpression
+            };
         }
     }
 
diff --git a/Reqnroll.VisualStudio/Snippets/Fallback/CucumberExpressionSkeletonProvider.cs b/Reqnroll.VisualStudio/Snippets/Fallback/CucumberExpressionSkeletonProvider.cs
@@ -4,8 +4,8 @@ namespace Reqnroll.VisualStudio.Snippets.Fallback;
 
 public class CucumberExpressionSkeletonProvider : DeveroomStepDefinitionSkeletonProvider
 {
-    public CucumberExpressionSkeletonProvider(ReqnrollProjectTraits projectTraits)
-        : base(projectTraits)
+    public CucumberExpressionSkeletonProvider(ReqnrollProjectTraits projectTraits, bool useAsync)
+        : base(projectTraits, useAsync)
     {
 
     }
diff --git a/Reqnroll.VisualStudio/Snippets/Fallback/DeveroomStepDefinitionSkeletonProvider.cs b/Reqnroll.VisualStudio/Snippets/Fallback/DeveroomStepDefinitionSkeletonProvider.cs
@@ -6,10 +6,12 @@ public abstract class DeveroomStepDefinitionSkeletonProvider
 {
     protected ReqnrollProjectTraits ProjectTraits { get; }
     protected abstract bool UseVerbatimStringForExpression { get; }
+    protected bool UseAsync { get; }
 
-    protected DeveroomStepDefinitionSkeletonProvider(ReqnrollProjectTraits projectTraits)
+    protected DeveroomStepDefinitionSkeletonProvider(ReqnrollProjectTraits projectTraits, bool useAsync)
     {
         ProjectTraits = projectTraits;
+        UseAsync = useAsync;
     }
 
     public string GetStepDefinitionSkeletonSnippet(UndefinedStepDescriptor undefinedStep,
@@ -23,9 +25,10 @@ public string GetStepDefinitionSkeletonSnippet(UndefinedStepDescriptor undefined
         var methodName = GetMethodName(undefinedStep, analyzedStepText);
         var parameters = string.Join(", ", analyzedStepText.Parameters.Select(ToDeclaration));
         var stringPrefix = UseVerbatimStringForExpression ? "@" : "";
+        var returnSignature = UseAsync ? "async Task" : "void";
 
         var method = $"[{undefinedStep.ScenarioBlock}({stringPrefix}\"{regex}\")]" + newLine +
-                     $"public void {methodName}({parameters})" + newLine +
+                     $"public {returnSignature} {methodName}{(UseAsync ? "Async" : "")}({parameters})" + newLine +
                      "{" + newLine +
                      $"{indent}throw new PendingStepException();" + newLine +
                      "}" + newLine;
diff --git a/Reqnroll.VisualStudio/Snippets/Fallback/RegexStepDefinitionSkeletonProvider.cs b/Reqnroll.VisualStudio/Snippets/Fallback/RegexStepDefinitionSkeletonProvider.cs
@@ -2,7 +2,7 @@ namespace Reqnroll.VisualStudio.Snippets.Fallback;
 
 public class RegexStepDefinitionSkeletonProvider : DeveroomStepDefinitionSkeletonProvider
 {
-    public RegexStepDefinitionSkeletonProvider(ReqnrollProjectTraits projectTraits) : base(projectTraits)
+    public RegexStepDefinitionSkeletonProvider(ReqnrollProjectTraits projectTraits, bool useAsync) : base(projectTraits, useAsync)
     {
     }
 
diff --git a/Reqnroll.VisualStudio/Snippets/SnippetExpressionStyle.cs b/Reqnroll.VisualStudio/Snippets/SnippetExpressionStyle.cs
@@ -3,5 +3,26 @@ namespace Reqnroll.VisualStudio.Snippets;
 public enum SnippetExpressionStyle
 {
     RegularExpression,
-    CucumberExpression
+    CucumberExpression,
+    AsyncRegularExpression,
+    AsyncCucumberExpression
 }
+
+public static class SnippetExpressionStyleExtensions
+{
+    public static bool IsAsync(this SnippetExpressionStyle style)
+    {
+        if (style == SnippetExpressionStyle.AsyncRegularExpression
+            || style == SnippetExpressionStyle.AsyncCucumberExpression)
+            return true;
+        return false;
+    }
+
+    public static bool IsCucumber(this SnippetExpressionStyle style)
+    {
+        if (style == SnippetExpressionStyle.CucumberExpression
+            || style == SnippetExpressionStyle.AsyncCucumberExpression)
+            return true;
+        return false;
+    }
+}
diff --git a/Reqnroll.VisualStudio/Snippets/SnippetService.cs b/Reqnroll.VisualStudio/Snippets/SnippetService.cs
@@ -21,9 +21,9 @@ public string GetStepDefinitionSkeletonSnippet(UndefinedStepDescriptor undefined
         try
         {
             var projectTraits = _projectScope.GetProjectSettings().ReqnrollProjectTraits;
-            var skeletonProvider = expressionStyle == SnippetExpressionStyle.CucumberExpression
-                ? (DeveroomStepDefinitionSkeletonProvider) new CucumberExpressionSkeletonProvider(projectTraits)
-                : new RegexStepDefinitionSkeletonProvider(projectTraits);
+            var skeletonProvider = expressionStyle.IsCucumber()
+                ? (DeveroomStepDefinitionSkeletonProvider) new CucumberExpressionSkeletonProvider(projectTraits, expressionStyle.IsAsync())
+                : new RegexStepDefinitionSkeletonProvider(projectTraits, expressionStyle.IsAsync());
 
             var configuration = _projectScope.GetDeveroomConfiguration();
             newLine = newLine ?? Environment.NewLine;
diff --git a/Tests/Reqnroll.VisualStudio.Specs/Features/Editor/Commands/DefineStepsCommand.feature b/Tests/Reqnroll.VisualStudio.Specs/Features/Editor/Commands/DefineStepsCommand.feature
@@ -163,3 +163,44 @@ Scenario: DefineSteps command properly escapes empty brackets when using Regex e
 		| type | expression |
 		| When | I use \\(parenthesis\), \\{curly braces}, \\\ backslash, and/or \\. period |
 
+Scenario: DefineSteps command abides by reqnroll.json configuration for async method declaration
+	Given there is a Reqnroll project scope
+	And the following feature file in the editor
+		"""
+		Feature: Feature Using Regex Style
+		
+		Scenario: Client has a simple basket
+			Given the client has a basket
+		"""
+	And the reqnroll.json configuration file contains
+		"""
+		{ 
+			"trace": { "stepDefinitionSkeletonStyle": "AsyncRegexAttribute" }
+		}
+		"""
+	And the project is built and the initial binding discovery is performed
+	When I invoke the "Define Steps" command
+	Then the define steps dialog should be opened with the following step definition skeletons
+		| Method                                                   |
+		| MyProject.StepDefinitions1.GivenTheClientHasABasketAsync |
+
+Scenario: DefineSteps command abides by reqnroll.json configuration for synchronous method declaration
+	Given there is a Reqnroll project scope
+	And the following feature file in the editor
+		"""
+		Feature: Feature Using Regex Style
+		
+		Scenario: Client has a simple basket
+			Given the client has a basket
+		"""
+	And the reqnroll.json configuration file contains
+		"""
+		{ 
+			"trace": { "stepDefinitionSkeletonStyle": "RegexAttribute" }
+		}
+		"""
+	And the project is built and the initial binding discovery is performed
+	When I invoke the "Define Steps" command
+	Then the define steps dialog should be opened with the following step definition skeletons
+		| Method                                              |
+		| MyProject.StepDefinitions1.GivenTheClientHasABasket |
diff --git a/Tests/Reqnroll.VisualStudio.Specs/StepDefinitions/ProjectSystemSteps.cs b/Tests/Reqnroll.VisualStudio.Specs/StepDefinitions/ProjectSystemSteps.cs
@@ -797,7 +797,8 @@ private StepDefinitionSnippetData[] ParseSnippetsFromFile(string text,
             {
                 Type = sd.Type,
                 Regex = sd.Regex,
-                Expression = sd.Expression
+                Expression = sd.Expression,
+                Method = sd.Method
             }).ToArray();
     }
 
@@ -987,5 +988,6 @@ private class StepDefinitionSnippetData
         public string Type { get; set; }
         public string Regex { get; set; }
         public string Expression { get; set; }
+        public string Method { get; set; }
     }
 }
diff --git a/Tests/Reqnroll.VisualStudio.Tests/Configuration/ReqnrollConfigDeserializerTests.cs b/Tests/Reqnroll.VisualStudio.Tests/Configuration/ReqnrollConfigDeserializerTests.cs
@@ -2,6 +2,7 @@
 
 using FluentAssertions;
 using Reqnroll.VisualStudio.Configuration;
+using Reqnroll.VisualStudio.Snippets;
 using Xunit;
 
 namespace Reqnroll.VisualStudio.Tests.Configuration;
@@ -149,4 +150,37 @@ public void Should_prioritize_language_binding_over_legacy_bindingCulture()
         config.ConfiguredBindingCulture.Should().Be("fr-FR"); // language.binding takes priority
         config.BindingCulture.Should().Be("fr-FR");
     }
+
+    [Theory]
+    [InlineData("RegexAttribute", SnippetExpressionStyle.RegularExpression)]
+    [InlineData("CucumberExpressionAttribute", SnippetExpressionStyle.CucumberExpression)]
+    [InlineData("AsyncRegexAttribute", SnippetExpressionStyle.AsyncRegularExpression)]
+    [InlineData("AsyncCucumberExpressionAttribute", SnippetExpressionStyle.AsyncCucumberExpression)]
+    [InlineData("InvalidValue", SnippetExpressionStyle.CucumberExpression)] // Default fallback
+    [InlineData("", SnippetExpressionStyle.CucumberExpression)] // Default fallback
+    [InlineData(null, SnippetExpressionStyle.CucumberExpression)] // Default fallback
+    public void Should_set_stepDefinitionSkeletonStyle_from_reqnroll_json(string styleValue, SnippetExpressionStyle expectedStyle)
+    {
+        // Arrange
+        var deserializer = new ReqnrollConfigDeserializer();
+        var config = new DeveroomConfiguration();
+        var styleJson = styleValue != null
+            ? $@"
+            {{
+              ""trace"": {{
+                ""stepDefinitionSkeletonStyle"": ""{styleValue}""
+              }}
+            }}"
+            : @"
+            {
+              ""trace"": {
+              }
+            }";
+
+        // Act
+        deserializer.Populate(styleJson, config);
+
+        // Assert
+        config.SnippetExpressionStyle.Should().Be(expectedStyle);
+    }
 }
diff --git a/Tests/Reqnroll.VisualStudio.Tests/Snippets/SnippetServiceTests.cs b/Tests/Reqnroll.VisualStudio.Tests/Snippets/SnippetServiceTests.cs
@@ -0,0 +1,53 @@
+using FluentAssertions;
+using NSubstitute;
+using Reqnroll.VisualStudio.Snippets;
+using Reqnroll.VisualStudio.ProjectSystem;
+using Reqnroll.VisualStudio.ProjectSystem.Configuration;
+using Xunit;
+
+namespace Reqnroll.VisualStudio.Tests.Snippets
+{
+    public class SnippetServiceTests
+    {
+        private readonly IProjectScope _projectScope;
+        private readonly IIdeScope _ideScope;
+        private readonly IDeveroomLogger _logger;
+        private readonly SnippetService _service;
+        private readonly DeveroomConfiguration _defaultDeveroomConfig;
+        private readonly ITestOutputHelper testOutputHelper;
+
+        public SnippetServiceTests(ITestOutputHelper testOutputHelper)
+        {
+            _ideScope = new StubIdeScope(testOutputHelper);
+            _logger = new StubLogger();
+            _projectScope = new StubProjectScope(@"C:\", "bin", _ideScope, new List<NuGetPackageReference>(), "net8");
+
+            _defaultDeveroomConfig = new DeveroomConfiguration();
+
+            // Construct the service with the substitute
+            _service = new SnippetService(_projectScope);
+            this.testOutputHelper = testOutputHelper;
+        }
+
+        [Theory]
+        [InlineData(SnippetExpressionStyle.RegularExpression, "[Given(@\"pattern\")]\npublic void GivenPattern()\n{\nthrow new PendingStepException();\n}\n")]
+        [InlineData(SnippetExpressionStyle.AsyncRegularExpression, "[Given(@\"pattern\")]\npublic async Task GivenPatternAsync()\n{\nthrow new PendingStepException();\n}\n")]
+        [InlineData(SnippetExpressionStyle.CucumberExpression, "[Given(\"pattern\")]\npublic void GivenPattern()\n{\nthrow new PendingStepException();\n}\n")]
+        [InlineData(SnippetExpressionStyle.AsyncCucumberExpression, "[Given(\"pattern\")]\npublic async Task GivenPatternAsync()\n{\nthrow new PendingStepException();\n}\n")]
+        public void Generates_correct_step_definition_snippet(SnippetExpressionStyle style, string expectedSnippet)
+        {
+            // Arrange
+            var undefinedStep = new DeveroomGherkinStep(new Gherkin.Ast.Location(0, 0), "Given ", Gherkin.StepKeywordType.Context, "pattern", null, StepKeyword.Given, ScenarioBlock.Given);
+            var undefinedStepDescriptor = new UndefinedStepDescriptor(undefinedStep, "pattern");
+            var indent = "";
+            var newLine = "\n";
+
+            // Act
+            var snippet = _service.GetStepDefinitionSkeletonSnippet(
+                undefinedStepDescriptor, style, indent, newLine);
+
+            // Assert
+            snippet.Should().Be(expectedSnippet);
+        }
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -4,8 +4,8 @@ namespace Reqnroll.VisualStudio.Snippets.Fallback;`
`4`	`4`
`5`	`5`	`public class CucumberExpressionSkeletonProvider : DeveroomStepDefinitionSkeletonProvider`
`6`	`6`	`{`
`7`		`- public CucumberExpressionSkeletonProvider(ReqnrollProjectTraits projectTraits)`
`8`		`- : base(projectTraits)`
	`7`	`+ public CucumberExpressionSkeletonProvider(ReqnrollProjectTraits projectTraits, bool useAsync)`
	`8`	`+ : base(projectTraits, useAsync)`
`9`	`9`	`{`
`10`	`10`
`11`	`11`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,7 @@ namespace Reqnroll.VisualStudio.Snippets.Fallback;`
`2`	`2`
`3`	`3`	`public class RegexStepDefinitionSkeletonProvider : DeveroomStepDefinitionSkeletonProvider`
`4`	`4`	`{`
`5`		`- public RegexStepDefinitionSkeletonProvider(ReqnrollProjectTraits projectTraits) : base(projectTraits)`
	`5`	`+ public RegexStepDefinitionSkeletonProvider(ReqnrollProjectTraits projectTraits, bool useAsync) : base(projectTraits, useAsync)`
`6`	`6`	`{`
`7`	`7`	`}`
`8`	`8`
Original file line number	Diff line number	Diff line change
`@@ -797,7 +797,8 @@ private StepDefinitionSnippetData[] ParseSnippetsFromFile(string text,`
`797`	`797`	`{`
`798`	`798`	`Type = sd.Type,`
`799`	`799`	`Regex = sd.Regex,`
`800`		`- Expression = sd.Expression`
	`800`	`+ Expression = sd.Expression,`
	`801`	`+ Method = sd.Method`
`801`	`802`	`}).ToArray();`
`802`	`803`	`}`
`803`	`804`
`@@ -987,5 +988,6 @@ private class StepDefinitionSnippetData`
`987`	`988`	`public string Type { get; set; }`
`988`	`989`	`public string Regex { get; set; }`
`989`	`990`	`public string Expression { get; set; }`
	`991`	`+ public string Method { get; set; }`
`990`	`992`	`}`
`991`	`993`	`}`