Start implementation of multiple example tables

Author: jsa34

src/pytest_bdd/generation.py

@@ -62,6 +62,7 @@ def generate_code(features: list[Feature], scenarios: list[ScenarioTemplate], st
     """Generate test code for the given filenames."""
     grouped_steps = group_steps(steps)
     template = template_lookup.get_template("test.py.mak")
+
     code = template.render(
         features=features,
         scenarios=scenarios,
@@ -83,42 +84,39 @@ def show_missing_code(config: Config) -> int:
 def print_missing_code(scenarios: list[ScenarioTemplate], steps: list[Step]) -> None:
     """Print missing code with TerminalWriter."""
     tw = TerminalWriter()
-    scenario = step = None
 
     for scenario in scenarios:
         tw.line()
         tw.line(
-            'Scenario "{scenario.name}" is not bound to any test in the feature "{scenario.feature.name}"'
-            " in the file {scenario.feature.filename}:{scenario.line_number}".format(scenario=scenario),
+            f'Scenario "{scenario.name}" is not bound to any test in the feature "{scenario.feature.name}"'
+            f" in the file {scenario.feature.filename}:{scenario.line_number}",
             red=True,
         )
 
-    if scenario:
-        tw.sep("-", red=True)
+    tw.sep("-", red=True)
 
     for step in steps:
         tw.line()
         if step.scenario is not None:
             tw.line(
-                """Step {step} is not defined in the scenario "{step.scenario.name}" in the feature"""
-                """ "{step.scenario.feature.name}" in the file"""
-                """ {step.scenario.feature.filename}:{step.line_number}""".format(step=step),
+                f"""Step {step} is not defined in the scenario "{step.scenario.name}" in the feature"""
+                f""" "{step.scenario.feature.name}" in the file"""
+                f" {step.scenario.feature.filename}:{step.line_number}",
                 red=True,
             )
         elif step.background is not None:
             tw.line(
-                """Step {step} is not defined in the background of the feature"""
-                """ "{step.background.feature.name}" in the file"""
-                """ {step.background.feature.filename}:{step.line_number}""".format(step=step),
+                f"""Step {step} is not defined in the background of the feature"""
+                f""" "{step.background.feature.name}" in the file"""
+                f" {step.background.feature.filename}:{step.line_number}",
                 red=True,
             )
 
-    if step:
-        tw.sep("-", red=True)
-
-    tw.line("Please place the code above to the test file(s):")
+    tw.sep("-", red=True)
+    tw.line("Please place the code above into the test file(s):")
     tw.line()
 
+    # Group features and generate the test code
     features = sorted(
         (scenario.feature for scenario in scenarios), key=lambda feature: feature.name or feature.filename
     )

src/pytest_bdd/gherkin_parser.py

@@ -107,6 +107,7 @@ class ExamplesTable:
     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:
@@ -115,6 +116,7 @@ def from_dict(cls, data: dict[str, Any]) -> Self:
             name=data.get("name"),
             table_header=Row.from_dict(data["tableHeader"]) if data.get("tableHeader") else None,
             table_body=[Row.from_dict(row) for row in data.get("tableBody", [])],
+            tags=[Tag.from_dict(tag) for tag in data["tags"]]
         )
 
 

src/pytest_bdd/parser.py

@@ -124,7 +124,7 @@ class ScenarioTemplate:
     description: str | None = None
     tags: set[str] = field(default_factory=set)
     _steps: list[Step] = field(init=False, default_factory=list)
-    examples: Examples | None = field(default_factory=Examples)
+    examples: list[Examples] = field(default_factory=list)
 
     def add_step(self, step: Step) -> None:
         """Add a step to the scenario.
@@ -144,19 +144,20 @@ def steps(self) -> list[Step]:
         """
         return (self.feature.background.steps if self.feature.background else []) + self._steps
 
-    def render(self, context: Mapping[str, Any]) -> Scenario:
+    def render(self, context: Mapping[str, Any]) -> list[Scenario]:
         """Render the scenario with the given context.
 
         Args:
             context (Mapping[str, Any]): The context for rendering steps.
 
         Returns:
-            Scenario: A Scenario object with steps rendered based on the context.
+            list[Scenario]: A list of Scenario objects with steps rendered based on the context.
         """
-        background_steps = self.feature.background.steps if self.feature.background else []
-        scenario_steps = [
+        scenarios = []
+        base_context = context or {}
+        base_steps = [
             Step(
-                name=step.render(context),
+                name=step.render(base_context),
                 type=step.type,
                 indent=step.indent,
                 line_number=step.line_number,
@@ -166,16 +167,52 @@ def render(self, context: Mapping[str, Any]) -> Scenario:
             )
             for step in self._steps
         ]
-        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,
-        )
+        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
 
 
 @dataclass(eq=False)
@@ -401,6 +438,7 @@ def parse_scenario(self, scenario_data: GherkinScenario, feature: Feature) -> Sc
         for step in self.parse_steps(scenario_data.steps):
             scenario.add_step(step)
 
+        # Loop over multiple example tables if they exist
         for example_data in scenario_data.examples:
             examples = Examples(
                 line_number=example_data.location.line,
@@ -413,7 +451,7 @@ def parse_scenario(self, scenario_data: GherkinScenario, feature: Feature) -> Sc
                     for row in example_data.table_body:
                         values = [cell.value or "" for cell in row.cells]
                         examples.add_example(values)
-                    scenario.examples = examples
+                scenario.examples.append(examples)
 
         return scenario
 

src/pytest_bdd/plugin.py

@@ -49,7 +49,7 @@ def _pytest_bdd_example() -> dict:
 
     If no outline is used, we just return an empty dict to render
     the current template without any actual variable.
-    Otherwise pytest_bdd will add all the context variables in this fixture
+    Otherwise, pytest_bdd will add all the context variables in this fixture
     from the example definitions in the feature file.
     """
     return {}

src/pytest_bdd/scenario.py

@@ -276,8 +276,9 @@ 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
-            scenario = templated_scenario.render(_pytest_bdd_example)
-            _execute_scenario(feature, scenario, request)
+            rendered_scenarios = templated_scenario.render(_pytest_bdd_example)
+            for scenario in rendered_scenarios:
+                _execute_scenario(feature, scenario, request)
             fixture_values = [request.getfixturevalue(arg) for arg in func_args]
             return fn(*fixture_values)
 
@@ -289,7 +290,7 @@ def scenario_wrapper(request: FixtureRequest, _pytest_bdd_example: dict[str, str
                 example_parametrizations,
             )(scenario_wrapper)
 
-        for tag in templated_scenario.tags.union(feature.tags):
+        for tag in templated_scenario.tags | feature.tags:
             config = CONFIG_STACK[-1]
             config.hook.pytest_bdd_apply_tag(tag=tag, function=scenario_wrapper)
 
@@ -303,12 +304,14 @@ def scenario_wrapper(request: FixtureRequest, _pytest_bdd_example: dict[str, str
 def collect_example_parametrizations(
     templated_scenario: ScenarioTemplate,
 ) -> list[ParameterSet] | None:
-    if templated_scenario.examples is None:
+    if not templated_scenario.examples:
         return None
-    if contexts := list(templated_scenario.examples.as_contexts()):
-        return [pytest.param(context, id="-".join(context.values())) for context in contexts]
-    else:
+    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]
 
 
 def scenario(