Implement multiple example tables

Author: jsa34

src/pytest_bdd/gherkin_parser.py

@@ -104,10 +104,10 @@ def from_dict(cls, data: dict[str, Any]) -> Self:
 @dataclass
 class ExamplesTable:
     location: Location
+    tags: list[Tag]
     name: str | None = None
     table_header: Row | None = None
     table_body: list[Row] | None = field(default_factory=list)
-    tags: list[str] = field(default_factory=set)
 
     @classmethod
     def from_dict(cls, data: dict[str, Any]) -> Self:

src/pytest_bdd/parser.py

@@ -22,6 +22,18 @@
 STEP_PARAM_RE = re.compile(r"<(.+?)>")
 
 
+def get_tag_names(tag_data: list[GherkinTag]) -> set[str]:
+    """Extract tag names from tag data.
+
+    Args:
+        tag_data (List[dict]): The tag data to extract names from.
+
+    Returns:
+        set[str]: A set of tag names.
+    """
+    return {tag.name.lstrip("@") for tag in tag_data}
+
+
 @dataclass(eq=False)
 class Feature:
     """Represents a feature parsed from a feature file.
@@ -64,6 +76,7 @@ class Examples:
     name: str | None = None
     example_params: list[str] = field(default_factory=list)
     examples: list[Sequence[str]] = field(default_factory=list)
+    tags: set[str] = field(default_factory=set)
 
     def set_param_names(self, keys: Iterable[str]) -> None:
         """Set the parameter names for the examples.
@@ -144,20 +157,19 @@ def steps(self) -> list[Step]:
         """
         return (self.feature.background.steps if self.feature.background else []) + self._steps
 
-    def render(self, context: Mapping[str, Any]) -> list[Scenario]:
+    def render(self, context: Mapping[str, Any]) -> Scenario:
         """Render the scenario with the given context.
 
         Args:
             context (Mapping[str, Any]): The context for rendering steps.
 
         Returns:
-            list[Scenario]: A list of Scenario objects with steps rendered based on the context.
+            Scenario: A Scenario object with steps rendered based on the context.
         """
-        scenarios = []
-        base_context = context or {}
-        base_steps = [
+        background_steps = self.feature.background.steps if self.feature.background else []
+        scenario_steps = [
             Step(
-                name=step.render(base_context),
+                name=step.render(context),
                 type=step.type,
                 indent=step.indent,
                 line_number=step.line_number,
@@ -167,52 +179,16 @@ def render(self, context: Mapping[str, Any]) -> list[Scenario]:
             )
             for step in self._steps
         ]
-        background_steps = self.feature.background.steps if self.feature.background else []
-
-        if not self.examples:
-            # Render a single scenario without examples
-            scenarios.append(
-                Scenario(
-                    feature=self.feature,
-                    keyword=self.keyword,
-                    name=self.name,
-                    line_number=self.line_number,
-                    steps=background_steps + base_steps,
-                    tags=self.tags,
-                    description=self.description,
-                )
-            )
-        else:
-            # Render multiple scenarios with each example context
-            for examples in self.examples:
-                for example_context in examples.as_contexts():
-                    full_context = {**base_context, **example_context}
-                    example_steps = [
-                        Step(
-                            name=step.render(full_context),
-                            type=step.type,
-                            indent=step.indent,
-                            line_number=step.line_number,
-                            keyword=step.keyword,
-                            datatable=step.datatable,
-                            docstring=step.docstring,
-                        )
-                        for step in self._steps
-                    ]
-                    example_tags = self.tags.union(examples.tags if hasattr(examples, "tags") else set())
-                    scenarios.append(
-                        Scenario(
-                            feature=self.feature,
-                            keyword=self.keyword,
-                            name=self.name,
-                            line_number=self.line_number,
-                            steps=background_steps + example_steps,
-                            tags=example_tags,
-                            description=self.description,
-                        )
-                    )
-
-        return scenarios
+        steps = background_steps + scenario_steps
+        return Scenario(
+            feature=self.feature,
+            keyword=self.keyword,
+            name=self.name,
+            line_number=self.line_number,
+            steps=steps,
+            tags=self.tags,
+            description=self.description,
+        )
 
 
 @dataclass(eq=False)
@@ -364,18 +340,6 @@ def __init__(self, basedir: str, filename: str, encoding: str = "utf-8"):
         self.rel_filename = os.path.join(os.path.basename(basedir), filename)
         self.encoding = encoding
 
-    @staticmethod
-    def get_tag_names(tag_data: list[GherkinTag]) -> set[str]:
-        """Extract tag names from tag data.
-
-        Args:
-            tag_data (List[dict]): The tag data to extract names from.
-
-        Returns:
-            set[str]: A set of tag names.
-        """
-        return {tag.name.lstrip("@") for tag in tag_data}
-
     def parse_steps(self, steps_data: list[GherkinStep]) -> list[Step]:
         """Parse a list of step data into Step objects.
 
@@ -432,7 +396,7 @@ def parse_scenario(self, scenario_data: GherkinScenario, feature: Feature) -> Sc
             name=scenario_data.name,
             line_number=scenario_data.location.line,
             templated=templated,
-            tags=self.get_tag_names(scenario_data.tags),
+            tags=get_tag_names(scenario_data.tags),
             description=textwrap.dedent(scenario_data.description),
         )
         for step in self.parse_steps(scenario_data.steps):
@@ -443,6 +407,7 @@ def parse_scenario(self, scenario_data: GherkinScenario, feature: Feature) -> Sc
             examples = Examples(
                 line_number=example_data.location.line,
                 name=example_data.name,
+                tags=get_tag_names(example_data.tags),
             )
             if example_data.table_header is not None:
                 param_names = [cell.value for cell in example_data.table_header.cells]
@@ -482,7 +447,7 @@ def parse(self) -> Feature:
             filename=self.abs_filename,
             rel_filename=self.rel_filename,
             name=feature_data.name,
-            tags=self.get_tag_names(feature_data.tags),
+            tags=get_tag_names(feature_data.tags),
             background=None,
             line_number=feature_data.location.line,
             description=textwrap.dedent(feature_data.description),

src/pytest_bdd/scenario.py

@@ -22,6 +22,7 @@
 
 import pytest
 from _pytest.fixtures import FixtureDef, FixtureManager, FixtureRequest, call_fixture_func
+from pytest import warns, PytestUnknownMarkWarning
 from typing_extensions import ParamSpec
 
 from . import exceptions
@@ -276,9 +277,8 @@ def decorator(*args: Callable[P, T]) -> Callable[P, T]:
         @pytest.mark.usefixtures(*func_args)
         def scenario_wrapper(request: FixtureRequest, _pytest_bdd_example: dict[str, str]) -> Any:
             __tracebackhide__ = True
-            rendered_scenarios = templated_scenario.render(_pytest_bdd_example)
-            for scenario in rendered_scenarios:
-                _execute_scenario(feature, scenario, request)
+            scenario = templated_scenario.render(_pytest_bdd_example)
+            _execute_scenario(feature, scenario, request)
             fixture_values = [request.getfixturevalue(arg) for arg in func_args]
             return fn(*fixture_values)
 
@@ -304,14 +304,24 @@ def scenario_wrapper(request: FixtureRequest, _pytest_bdd_example: dict[str, str
 def collect_example_parametrizations(
     templated_scenario: ScenarioTemplate,
 ) -> list[ParameterSet] | None:
-    if not templated_scenario.examples:
-        return None
-    contexts = []
-    for _examples in templated_scenario.examples:
-        contexts.extend(_examples.as_contexts())
-    if not contexts:
-        return None
-    return [pytest.param(context, id="-".join(context.values())) for context in contexts]
+    parametrizations = []
+    has_multiple_examples = len(templated_scenario.examples) > 1
+
+    for example_id, examples in enumerate(templated_scenario.examples):
+        with warns(PytestUnknownMarkWarning, match=r"Unknown pytest\.mark\.tag"):
+            example_marks = [pytest.mark.tag(tag) for tag in examples.tags]
+        for context in examples.as_contexts() or [{}]:
+            test_id = "-".join((str(example_id), *context.values())) if has_multiple_examples else "-".join(
+                context.values())
+            parametrizations.append(
+                pytest.param(
+                    context,
+                    id=test_id,
+                    marks=example_marks,
+                ),
+            )
+
+    return parametrizations or None
 
 
 def scenario(

tests/feature/test_outline.py

@@ -79,6 +79,61 @@ def test_outline(request):
     # fmt: on
 
 
+def test_multiple_outlined(pytester):
+    pytester.makefile(
+        ".feature",
+        outline=textwrap.dedent(
+            """\
+            Feature: Outline
+                Scenario Outline: Outlined given, when, thens with multiple examples tables
+                    Given there are <start> cucumbers
+                    When I eat <eat> cucumbers
+                    Then I should have <left> cucumbers
+
+                    @positive
+                    Examples: Positive result
+                        | start | eat | left |
+                        |  12   |  5  |  7   |
+                        |  5    |  4  |  1   |
+                    
+                    @negative
+                    Examples: Negative result
+                        | start | eat | left |
+                        |  3    |  9  |  -6  |
+                        |  1    |  4  |  -3  |
+            """
+        ),
+    )
+
+    pytester.makeconftest(textwrap.dedent(STEPS))
+
+    pytester.makepyfile(
+        textwrap.dedent(
+            """\
+        from pytest_bdd import scenario
+
+        @scenario(
+            "outline.feature",
+            "Outlined given, when, thens with multiple examples tables",
+        )
+        def test_outline(request):
+            pass
+
+        """
+        )
+    )
+    result = pytester.runpytest("-s")
+    result.assert_outcomes(passed=4)
+    # fmt: off
+    assert collect_dumped_objects(result) == [
+        12, 5.0, "7",
+        5, 4.0, "1",
+        3, 9.0, "-6",
+        1, 4.0, "-3",
+    ]
+    # fmt: on
+
+
 def test_unused_params(pytester):
     """Test parametrized scenario when the test function lacks parameters."""
 

tests/generation/test_generate_missing.py

@@ -84,7 +84,7 @@ def test_missing_steps():
         ['Step Given "I have a foobar" is not defined in the background of the feature "Missing code generation" *']
     )
 
-    result.stdout.fnmatch_lines(["Please place the code above to the test file(s):"])
+    result.stdout.fnmatch_lines(["Please place the code above into the test file(s):"])
 
 
 def test_generate_missing_with_step_parsers(pytester):

tests/parser/test_parser.py

@@ -163,6 +163,7 @@ def test_parser():
                             ExamplesTable(
                                 location=Location(column=5, line=26),
                                 name="",
+                                tags=[],
                                 table_header=Row(
                                     id="11",
                                     location=Location(column=7, line=27),