Add datatables

Fix casing of attributes of some parser classes (camel -> snake case)
Fix mistake that datatables are parsed the same as example tables.
Make data_table fixture only generated if a data table exists for a given step, otherwise the fixture is not generated.
Added methods to translate data table to a map/dict (using the first row as keys) and the ability to transpose the datatable for the case of vertical vs. horizontal data tables.

Author: jsa34

src/pytest_bdd/gherkin_parser.py

@@ -101,22 +101,83 @@ def from_dict(cls, data: dict[str, Any]) -> Self:
 
 
 @dataclass
-class DataTable:
+class ExamplesTable:
     location: Location
     name: str | None = None
-    tableHeader: Row | None = None
-    tableBody: list[Row] | None = field(default_factory=list)
+    table_header: Row | None = None
+    table_body: list[Row] | None = field(default_factory=list)
 
     @classmethod
     def from_dict(cls, data: dict[str, Any]) -> Self:
         return cls(
             location=Location.from_dict(data["location"]),
             name=data.get("name"),
-            tableHeader=Row.from_dict(data["tableHeader"]) if data.get("tableHeader") else None,
-            tableBody=[Row.from_dict(row) for row in data.get("tableBody", [])],
+            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", [])],
         )
 
 
+@dataclass
+class DataTable:
+    location: Location
+    rows: list[Row]
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> Self:
+        return cls(
+            location=Location.from_dict(data["location"]), rows=[Row.from_dict(row) for row in data.get("rows", [])]
+        )
+
+    def transpose(self) -> Self:
+        # Transpose the cells, turning rows into columns
+        if not self.rows:
+            return self  # Return itself if there are no rows to transpose
+
+        # Get the list of lists of cell values (i.e., extract all row cells)
+        cells_matrix = [row.cells for row in self.rows]
+
+        # Check the maximum number of columns (to handle different row lengths)
+        max_columns = max(len(row) for row in cells_matrix)
+
+        # Create a list to store the transposed cells
+        transposed_cells = []
+
+        for col_idx in range(max_columns):
+            # Create a new list for each transposed column
+            transposed_column = []
+            for row in cells_matrix:
+                if col_idx < len(row):  # Ensure we don't go out of bounds
+                    transposed_column.append(row[col_idx])
+                else:
+                    transposed_column.append(Cell(location=Location(0, 0), value=""))  # Empty cell
+
+            # Create a new row from the transposed column
+            transposed_row = Row(id=str(col_idx), location=self.location, cells=transposed_column)
+            transposed_cells.append(transposed_row)
+
+        # Return a new DataTable with transposed rows
+        return DataTable(location=self.location, rows=transposed_cells)
+
+    def to_dict(self) -> dict[str, list[str]]:
+        # Ensure there are at least two rows: one for the header and one for the values
+        if len(self.rows) < 2:
+            raise ValueError("DataTable needs at least two rows: one for headers and one for values")
+
+        # Extract the header row (first row)
+        header = [cell.value for cell in self.rows[0].cells]
+
+        # Extract the values from subsequent rows
+        values_rows = [[cell.value for cell in row.cells] for row in self.rows[1:]]
+
+        # Transpose the values so that each column corresponds to a header key
+        transposed_values = list(zip(*values_rows))
+
+        # Map each header to the corresponding list of values
+        result_dict = {header[i]: list(transposed_values[i]) for i in range(len(header))}
+
+        return result_dict
+
+
 @dataclass
 class DocString:
     content: str
@@ -136,22 +197,22 @@ def from_dict(cls, data: dict[str, Any]) -> Self:
 class Step:
     id: str
     keyword: str
-    keywordType: str
+    keyword_type: str
     location: Location
     text: str
-    dataTable: DataTable | None = None
-    docString: DocString | None = None
+    data_table: DataTable | None = None
+    doc_string: DocString | None = None
 
     @classmethod
     def from_dict(cls, data: dict[str, Any]) -> Self:
         return cls(
             id=data["id"],
             keyword=data["keyword"].strip(),
-            keywordType=data["keywordType"],
+            keyword_type=data["keywordType"],
             location=Location.from_dict(data["location"]),
             text=data["text"],
-            dataTable=DataTable.from_dict(data["dataTable"]) if data.get("dataTable") else None,
-            docString=DocString.from_dict(data["docString"]) if data.get("docString") else None,
+            data_table=DataTable.from_dict(data["dataTable"]) if data.get("dataTable") else None,
+            doc_string=DocString.from_dict(data["docString"]) if data.get("docString") else None,
         )
 
 
@@ -175,7 +236,7 @@ class Scenario:
     description: str
     steps: list[Step]
     tags: list[Tag]
-    examples: list[DataTable] = field(default_factory=list)
+    examples: list[ExamplesTable] = field(default_factory=list)
 
     @classmethod
     def from_dict(cls, data: dict[str, Any]) -> Self:
@@ -187,7 +248,7 @@ def from_dict(cls, data: dict[str, Any]) -> Self:
             description=data["description"],
             steps=[Step.from_dict(step) for step in data["steps"]],
             tags=[Tag.from_dict(tag) for tag in data["tags"]],
-            examples=[DataTable.from_dict(example) for example in data["examples"]],
+            examples=[ExamplesTable.from_dict(example) for example in data["examples"]],
         )
 
 

src/pytest_bdd/parser.py

@@ -9,6 +9,7 @@
 
 from .exceptions import StepError
 from .gherkin_parser import Background as GherkinBackground
+from .gherkin_parser import DataTable, ExamplesTable
 from .gherkin_parser import Feature as GherkinFeature
 from .gherkin_parser import GherkinDocument
 from .gherkin_parser import Scenario as GherkinScenario
@@ -170,6 +171,7 @@ def render(self, context: Mapping[str, Any]) -> Scenario:
                 indent=step.indent,
                 line_number=step.line_number,
                 keyword=step.keyword,
+                data_table=step.data_table,
             )
             for step in self._steps
         ]
@@ -225,11 +227,14 @@ class Step:
     line_number: int
     indent: int
     keyword: str
+    data_table: DataTable | None = None
     failed: bool = field(init=False, default=False)
     scenario: ScenarioTemplate | None = field(init=False, default=None)
     background: Background | None = field(init=False, default=None)
 
-    def __init__(self, name: str, type: str, indent: int, line_number: int, keyword: str) -> None:
+    def __init__(
+        self, name: str, type: str, indent: int, line_number: int, keyword: str, data_table: DataTable | None = None
+    ) -> None:
         """Initialize a step.
 
         Args:
@@ -244,6 +249,7 @@ def __init__(self, name: str, type: str, indent: int, line_number: int, keyword:
         self.indent = indent
         self.line_number = line_number
         self.keyword = keyword
+        self.data_table = data_table
 
     def __str__(self) -> str:
         """Return a string representation of the step.
@@ -342,8 +348,8 @@ def parse_steps(self, steps_data: list[GherkinStep]) -> list[Step]:
 
         def get_step_content(_gherkin_step: GherkinStep) -> str:
             step_name = strip_comments(_gherkin_step.text)
-            if _gherkin_step.docString:
-                step_name = f"{step_name}\n{_gherkin_step.docString.content}"
+            if _gherkin_step.doc_string:
+                step_name = f"{step_name}\n{_gherkin_step.doc_string.content}"
             return step_name
 
         if not steps_data:
@@ -372,6 +378,7 @@ def get_step_content(_gherkin_step: GherkinStep) -> str:
                     indent=step.location.column - 1,
                     line_number=step.location.line,
                     keyword=step.keyword.title(),
+                    data_table=step.data_table,
                 )
             )
         return steps
@@ -403,11 +410,11 @@ def parse_scenario(self, scenario_data: GherkinScenario, feature: Feature) -> Sc
                 line_number=example_data.location.line,
                 name=example_data.name,
             )
-            if example_data.tableHeader is not None:
-                param_names = [cell.value for cell in example_data.tableHeader.cells]
+            if example_data.table_header is not None:
+                param_names = [cell.value for cell in example_data.table_header.cells]
                 examples.set_param_names(param_names)
-                if example_data.tableBody is not None:
-                    for row in example_data.tableBody:
+                if example_data.table_body is not None:
+                    for row in example_data.table_body:
                         values = [cell.value or "" for cell in row.cells]
                         examples.add_example(values)
                     scenario.examples = examples

src/pytest_bdd/scenario.py

@@ -152,29 +152,27 @@ def get_fixture_path(fixture_def: FixtureDef) -> list[str]:
 
 
 def get_step_function(request: FixtureRequest, step: Step) -> StepFunctionContext | None:
-    """Get the step function (context) for the given step.
-
-    We first figure out what's the step fixture name that we have to inject.
-
-    Then we let `patch_argumented_step_functions` find out what step definition fixtures can parse the current step,
-    and it will inject them for the step fixture name.
-
-    Finally we let request.getfixturevalue(...) fetch the step definition fixture.
-    """
+    """Get the step function (context) for the given step, considering data_table."""
     __tracebackhide__ = True
     bdd_name = get_step_fixture_name(step=step)
 
     with inject_fixturedefs_for_step(step=step, fixturemanager=request._fixturemanager, node=request.node):
         try:
-            return cast(StepFunctionContext, request.getfixturevalue(bdd_name))
+            context = cast(StepFunctionContext, request.getfixturevalue(bdd_name))
+
+            # Attach data_table if present
+            if step.data_table:
+                context.data_table = step.data_table
+
+            return context
         except pytest.FixtureLookupError:
             return None
 
 
 def _execute_step_function(
     request: FixtureRequest, scenario: Scenario, step: Step, context: StepFunctionContext
 ) -> None:
-    """Execute step function."""
+    """Execute step function, with support for data_table."""
     __tracebackhide__ = True
     kw = {
         "request": request,
@@ -193,10 +191,16 @@ def _execute_step_function(
     args = get_args(context.step_func)
 
     try:
+        # Parse arguments, including handling for data_table
         parsed_args = context.parser.parse_arguments(step.name)
         assert parsed_args is not None, (
             f"Unexpected `NoneType` returned from " f"parse_arguments(...) in parser: {context.parser!r}"
         )
+
+        # Handle data_table if it exists
+        if step.data_table:
+            kwargs["data_table"] = step.data_table
+
         for arg, value in parsed_args.items():
             if arg in converters:
                 value = converters[arg](value)
@@ -217,6 +221,11 @@ def _execute_step_function(
 
     request.config.hook.pytest_bdd_after_step(**kw)
 
+    if context.target_fixture is not None:
+        inject_fixture(request, context.target_fixture, return_value)
+
+    request.config.hook.pytest_bdd_after_step(**kw)
+
 
 def _execute_scenario(feature: Feature, scenario: Scenario, request: FixtureRequest) -> None:
     """Execute the scenario.