Add support for Rule Backgrounds.

TechTalk.SpecFlow.Generator/Generation/ScenarioPartHelper.cs

@@ -50,6 +50,37 @@ public void SetupFeatureBackground(TestClassGenerationContext generationContext)
             backgroundMethod.Statements.AddRange(statements.ToArray());
 
         }
+        #region Rule Background Support
+
+        public void GenerateRuleBackgroundStepsApplicableForThisScenario(TestClassGenerationContext generationContext, ScenarioDefinitionInFeatureFile scenarioDefinition, List<CodeStatement> statementsWhenScenarioIsExecuted)
+        {
+            if (scenarioDefinition.Rule != null)
+            {
+                var rule = scenarioDefinition.Rule;
+                IEnumerable<CodeStatement> ruleBackgroundStatements = GenerateBackgroundStatementsForRule(generationContext, rule);
+                statementsWhenScenarioIsExecuted.AddRange(ruleBackgroundStatements);
+            }
+        }
+
+        private IEnumerable<CodeStatement> GenerateBackgroundStatementsForRule(TestClassGenerationContext context, Rule rule)
+        {
+            var background = rule.Children.OfType<Background>().FirstOrDefault();
+
+            if (background == null) return new List<CodeStatement>();
+
+            var statements = new List<CodeStatement>();
+            using (new SourceLineScope(_specFlowConfiguration, _codeDomHelper, statements, context.Document.SourceFilePath, background.Location))
+            {
+                foreach (var step in background.Steps)
+                {
+                    GenerateStep(context, statements, step, null);
+                }
+            }
+
+            return statements;
+        }
+
+        #endregion
 
         public void GenerateStep(TestClassGenerationContext generationContext, List<CodeStatement> statements, Step gherkinStep, ParameterSubstitution paramToIdentifier)
         {

TechTalk.SpecFlow.Generator/Generation/UnitTestMethodGenerator.cs

@@ -201,7 +201,7 @@ private void GenerateTestBody(
 
             GenerateScenarioInitializeCall(generationContext, scenarioDefinition, testMethod);
 
-            GenerateTestMethodBody(generationContext, scenarioDefinition, testMethod, paramToIdentifier, feature);
+            GenerateTestMethodBody(generationContext, scenarioDefinitionInFeatureFile, testMethod, paramToIdentifier, feature);
 
             GenerateScenarioCleanupMethodCall(generationContext, testMethod);
         }
@@ -238,8 +238,10 @@ private void AddVariableForArguments(CodeMemberMethod testMethod, ParameterSubst
             }
         }
 
-        internal void GenerateTestMethodBody(TestClassGenerationContext generationContext, StepsContainer scenario, CodeMemberMethod testMethod, ParameterSubstitution paramToIdentifier, SpecFlowFeature feature)
+        internal void GenerateTestMethodBody(TestClassGenerationContext generationContext, ScenarioDefinitionInFeatureFile scenarioDefinition, CodeMemberMethod testMethod, ParameterSubstitution paramToIdentifier, SpecFlowFeature feature)
         {
+            var scenario = scenarioDefinition.Scenario;
+
             var statementsWhenScenarioIsIgnored = new CodeStatement[] { new CodeExpressionStatement(CreateTestRunnerSkipScenarioCall()) };
 
             var callScenarioStartMethodExpression = new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), generationContext.ScenarioStartMethod.Name);
@@ -265,6 +267,7 @@ internal void GenerateTestMethodBody(TestClassGenerationContext generationContex
                 }
             }
 
+            _scenarioPartHelper.GenerateRuleBackgroundStepsApplicableForThisScenario(generationContext, scenarioDefinition, statementsWhenScenarioIsExecuted);
 
             foreach (var scenarioStep in scenario.Steps)
             {

Tests/TechTalk.SpecFlow.Specs/Features/Execution/RuleBackgroundExecution.feature

@@ -0,0 +1,126 @@
+@gherkin6
+Feature: Rule Background Steps Execution
+
+    Scenario: Should be able to execute scenarios in Rules that have backgrounds
+  	    Given the following binding class
+		     """
+             using TechTalk.SpecFlow;
+
+		     [Binding]
+		     public class RuleSteps1
+		     {
+
+			    [Given("something first as background")]
+			    public void GivenSomethingFirst() {
+                    global::Log.LogStep();
+                }
+
+                [When("I do something")]
+                public void WhenSomethingDone() {
+                    global::Log.LogStep();
+                }
+		     }
+		     """
+        Given there is a feature file in the project as
+            """
+                Feature: Simple Feature
+                Rule: first rule
+                Background: first rule background
+                    Given something first as background
+
+                Scenario: Scenario for the first rule
+                    When I do something
+            """
+
+
+        When I execute the tests
+        Then the binding method 'GivenSomethingFirst' is executed
+
+
+    Scenario: Should be able to execute backgrounds from multiple Rules
+  	    Given the following binding class
+		     """
+             using TechTalk.SpecFlow;
+
+		     [Binding]
+		     public class RuleSteps2
+		     {
+                private bool first_background_executed = false;
+                private bool second_background_executed = false;
+
+			    [Given("a first thing as background")]
+			    public void GivenaFirst() {
+                    global::Log.LogStep();
+                    first_background_executed = true;
+                }
+
+                [Then("the first of two background item was executed")]
+                public void ThenFirstOfTwoWasExecuted() {
+                    global::Log.LogStep();
+                    if (!first_background_executed) {
+                        throw new ApplicationException("First Background Step should have been executed");
+                    }
+                }
+
+                [Then("the first background item was not executed")]
+                public void ThenFirstWasNotExecuted() {
+                    global::Log.LogStep();
+                    if (first_background_executed) { 
+                        throw new ApplicationException("First Background Step should not have been executed");
+                    }
+                }
+
+			    [Given("something second as background")]
+			    public void GivenSomethingSecond() {
+                    global::Log.LogStep();
+                    second_background_executed = true;
+                }
+
+                [Then("the second background item was executed")]
+                public void ThenSecondWasExecuted() {
+                    global::Log.LogStep();
+                    if (!second_background_executed) { 
+                        throw new ApplicationException("Second Background Step should have been executed");
+                    }
+                }
+
+                [Then("the second background item was not executed")]
+                public void ThenSecondWasNotExecuted() {
+                    global::Log.LogStep();
+                    if (second_background_executed) { 
+                        throw new ApplicationException("Second Background Step should not have been executed");
+                    }
+                }
+
+                [When("I do something")]
+                public void WhenSomethingDone() {
+                    global::Log.LogStep();
+                }
+
+		     }
+		     """
+        Given there is a feature file in the project as
+            """
+                Feature: Simple Feature
+                Rule: first rule
+                    Background: first rule background
+                        Given a first thing as background
+
+                    Scenario: Scenario for the first rule
+                        When I do something
+                        Then the first of two background item was executed
+                        And the second background item was not executed
+
+                Rule: second rule
+                    Background: bg for second rule
+                        Given something second as background
+
+                    Scenario:Scenario for the second rule
+                        When I do something
+                        Then the second background item was executed
+                        And the first background item was not executed
+
+            """
+
+        When I execute the tests
+        Then all tests should pass

Tests/TechTalk.SpecFlow.Specs/Features/Parser/RuleSupport.feature

@@ -32,3 +32,24 @@ Scenario: Should be able to execute a simple passing scenario
     Then the execution summary should contain
         | Total | 
         | 5     | 
+
+
+
+    Scenario: Should be able to execute scenarios in Rules that have backgrounds
+    Given there is a feature file in the project as
+        """
+            Feature: Simple Feature
+            Rule: first rule
+            Background: first rule background
+                Given something
+
+            Scenario: Scenario for the first rule
+                When I do something
+
+        """
+    Given all steps are bound and pass
+    When I execute the tests
+    Then the execution summary should contain
+        | Total | 
+        | 1    | 
+

changelog.txt

@@ -12,6 +12,7 @@ Features:
 + Support Rule tags (can be used for hook filters, scoping and access through 'ScenarioInfo.CombinedTags')
 + Support for async step argument transformations. Fixes #2230
 + Support for ValueTask and ValueTask<T> binding methods (step definitions, hooks, step argument transformations)
++ Rules now support Background blocks
 + Collect binding errors (type load, binding, step definition) and report them as exception when any of the tests are executed.
 
 Changes: