Render docstrings and datatable cells with example table entries, just like step names currently are.

Author: jsa34

src/pytest_bdd/parser.py

@@ -23,6 +23,27 @@
 STEP_PARAM_RE = re.compile(r"<(.+?)>")
 
 
+def render_string(input_string: str, render_context: Mapping[str, Any]) -> str:
+    """
+    Render the string with the given context,
+    but avoid replacing text inside angle brackets if context is missing.
+
+    Args:
+        input_string (str): The string for which to render/replace params.
+        render_context (Mapping[str, Any]): The context for rendering the string.
+
+    Returns:
+        str: The rendered string with parameters replaced only if they exist in the context.
+    """
+
+    def replacer(m: re.Match) -> str:
+        varname = m.group(1)
+        # If the context contains the variable, replace it. Otherwise, leave it unchanged.
+        return str(render_context.get(varname, f"<{varname}>"))
+
+    return STEP_PARAM_RE.sub(replacer, input_string)
+
+
 def get_tag_names(tag_data: list[GherkinTag]) -> set[str]:
     """Extract tag names from tag data.
 
@@ -191,13 +212,13 @@ def render(self, context: Mapping[str, Any]) -> Scenario:
         """
         scenario_steps = [
             Step(
-                name=step.render(context),
+                name=step.render_step_name(context),
                 type=step.type,
                 indent=step.indent,
                 line_number=step.line_number,
                 keyword=step.keyword,
-                datatable=step.datatable,
-                docstring=step.docstring,
+                datatable=step.render_datatable(context),
+                docstring=step.render_docstring(context),
             )
             for step in self._steps
         ]
@@ -308,22 +329,50 @@ def params(self) -> tuple[str, ...]:
         """
         return tuple(frozenset(STEP_PARAM_RE.findall(self.name)))
 
-    def render(self, context: Mapping[str, Any]) -> str:
-        """Render the step name with the given context, but avoid replacing text inside angle brackets if context is missing.
+    def render_step_name(self, context: Mapping[str, Any]) -> str:
+        """
+        Render the step name with the given context,
+        but avoid replacing text inside angle brackets if context is missing.
 
         Args:
             context (Mapping[str, Any]): The context for rendering the step name.
 
         Returns:
             str: The rendered step name with parameters replaced only if they exist in the context.
         """
+        return render_string(self.name, context)
+
+    def render_datatable(self, context: Mapping[str, Any]) -> datatable | None:
+        """
+        Render the datatable with the given context,
+        but avoid replacing text inside angle brackets if context is missing.
+
+        Args:
+            context (Mapping[str, Any]): The context for rendering the datatable.
+
+        Returns:
+            datatable: The rendered datatable with parameters replaced only if they exist in the context.
+        """
+        if self.datatable:
+            rendered_datatable = self.datatable
+            for row in rendered_datatable.rows:
+                for cell in row.cells:
+                    cell.value = render_string(cell.value, context)
+            return rendered_datatable
+        return None
+
+    def render_docstring(self, context: Mapping[str, Any]) -> str | None:
+        """
+        Render the docstring with the given context,
+        but avoid replacing text inside angle brackets if context is missing.
 
-        def replacer(m: re.Match) -> str:
-            varname = m.group(1)
-            # If the context contains the variable, replace it. Otherwise, leave it unchanged.
-            return str(context.get(varname, f"<{varname}>"))
+        Args:
+            context (Mapping[str, Any]): The context for rendering the docstring.
 
-        return STEP_PARAM_RE.sub(replacer, self.name)
+        Returns:
+            str: The rendered docstring with parameters replaced only if they exist in the context.
+        """
+        return render_string(self.docstring, context) if self.docstring else None
 
 
 @dataclass(eq=False)

tests/feature/test_scenario.py

@@ -161,24 +161,32 @@ 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 |
-                | bar |
-        """,
+                | foo | data  | doc    |
+                | bar | table | string |
+        ''',
     )
     pytester.makepyfile(
         """
-        from pytest_bdd import scenarios, given, then, parsers
+        from pytest_bdd import scenarios, given, when, then, parsers
+        from pytest_bdd.utils import dump_obj
 
         scenarios("simple.feature")
 
@@ -190,14 +198,27 @@ def _():
         def _(foo):
             return "foo"
 
+        @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()
+    result = pytester.runpytest("-s")
     result.assert_outcomes(passed=2)
 
+    assert collect_dumped_objects(result) == [
+        ("datatable", [["table"], ["example"]]),
+        ("docstring", "This is a string"),
+    ]
+
 
 def test_multilanguage_support(pytester):
     """Test multilanguage support."""