Apply the rendering to background steps, and test for these

Author: jsa34

src/pytest_bdd/parser.py

@@ -210,6 +210,7 @@ def render(self, context: Mapping[str, Any]) -> Scenario:
         Returns:
             Scenario: A Scenario object with steps rendered based on the context.
         """
+        base_steps = self.all_background_steps + self._steps
         scenario_steps = [
             Step(
                 name=step.render_step_name(context),
@@ -220,15 +221,14 @@ def render(self, context: Mapping[str, Any]) -> Scenario:
                 datatable=step.render_datatable(context),
                 docstring=step.render_docstring(context),
             )
-            for step in self._steps
+            for step in base_steps
         ]
-        steps = self.all_background_steps + scenario_steps
         return Scenario(
             feature=self.feature,
             keyword=self.keyword,
-            name=self.name,
+            name=render_string(self.name, context),
             line_number=self.line_number,
-            steps=steps,
+            steps=scenario_steps,
             tags=self.tags,
             description=self.description,
             rule=self.rule,

tests/feature/test_scenario.py

@@ -161,32 +161,24 @@ def test_angular_brackets_are_not_parsed(pytester):
     """
     pytester.makefile(
         ".feature",
-        simple='''
+        simple="""
         Feature: Simple feature
             Scenario: Simple scenario
                 Given I have a <tag>
                 Then pass
 
             Scenario Outline: Outlined scenario
                 Given I have a templated <foo>
-                When I have a templated datatable
-                | <data>  |
-                | example |
-                And I have a templated docstring
-                """
-                This is a <doc>
-                """
                 Then pass
 
             Examples:
-                | foo | data  | doc    |
-                | bar | table | string |
-        ''',
+                | foo |
+                | bar |
+        """,
     )
     pytester.makepyfile(
         """
-        from pytest_bdd import scenarios, given, when, then, parsers
-        from pytest_bdd.utils import dump_obj
+        from pytest_bdd import scenarios, given, then, parsers
 
         scenarios("simple.feature")
 
@@ -198,23 +190,97 @@ def _():
         def _(foo):
             return "foo"
 
+        @then("pass")
+        def _():
+            pass
+        """
+    )
+    result = pytester.runpytest()
+    result.assert_outcomes(passed=2)
+
+
+def test_example_params(pytester):
+    """Test example params are rendered where necessary:
+    * Step names
+    * Docstring
+    * Datatables
+    """
+    pytester.makefile(
+        ".feature",
+        example_params='''
+        Feature: Example params
+            Background:
+                Given I have a background <background>
+                And my background has:
+                """
+                Background <background>
+                """
+
+                Scenario Outline: Outlined scenario
+                    Given I have a templated <foo>
+                    When I have a templated datatable
+                        | <data>  |
+                        | example |
+                    And I have a templated docstring
+                    """
+                    This is a <doc>
+                    """
+                    Then pass
+
+                Examples:
+                    | background | foo | data  | doc    |
+                    | parameter  | bar | table | string |
+        ''',
+    )
+    pytester.makepyfile(
+        """
+        from pytest_bdd import scenarios, given, when, then, parsers
+        from pytest_bdd.utils import dump_obj
+
+        scenarios("example_params.feature")
+
+
+        @given(parsers.parse("I have a background {background}"))
+        def _(background):
+            return dump_obj(("background", background))
+
+
+        @given(parsers.parse("I have a templated {foo}"))
+        def _(foo):
+            return "foo"
+
+
+        @given("my background has:")
+        def _(docstring):
+            return dump_obj(("background_docstring", docstring))
+
+
+        @given("I have a rule table:")
+        def _(datatable):
+            return dump_obj(("rule", datatable))
+
+
         @when("I have a templated datatable")
         def _(datatable):
             return dump_obj(("datatable", datatable))
 
+
         @when("I have a templated docstring")
         def _(docstring):
             return dump_obj(("docstring", docstring))
 
+
         @then("pass")
         def _():
             pass
         """
     )
     result = pytester.runpytest("-s")
-    result.assert_outcomes(passed=2)
+    result.assert_outcomes(passed=1)
 
     assert collect_dumped_objects(result) == [
+        ("background", "parameter"),
+        ("background_docstring", "Background parameter"),
         ("datatable", [["table"], ["example"]]),
         ("docstring", "This is a string"),
     ]