Response to feedback and make mypy happy.

Author: jsa34

src/pytest_bdd/compat.py

@@ -34,7 +34,7 @@ def inject_fixture(request: FixtureRequest, arg: str, value: Any) -> None:
 else:
 
     def getfixturedefs(fixturemanager: FixtureManager, fixturename: str, node: Node) -> Sequence[FixtureDef] | None:
-        return fixturemanager.getfixturedefs(fixturename, node.nodeid)
+        return fixturemanager.getfixturedefs(fixturename, node.nodeid)  # type: ignore
 
     def inject_fixture(request: FixtureRequest, arg: str, value: Any) -> None:
         """Inject fixture into pytest fixture request.
@@ -44,7 +44,7 @@ def inject_fixture(request: FixtureRequest, arg: str, value: Any) -> None:
         :param value: argument value
         """
         fd = FixtureDef(
-            fixturemanager=request._fixturemanager,
+            fixturemanager=request._fixturemanager,  # type: ignore
             baseid=None,
             argname=arg,
             func=lambda: value,

src/pytest_bdd/cucumber_json.py

@@ -35,14 +35,14 @@ def configure(config: Config) -> None:
     cucumber_json_path = config.option.cucumber_json_path
     # prevent opening json log on worker nodes (xdist)
     if cucumber_json_path and not hasattr(config, "workerinput"):
-        config._bddcucumberjson = LogBDDCucumberJSON(cucumber_json_path)
-        config.pluginmanager.register(config._bddcucumberjson)
+        config._bddcucumberjson = LogBDDCucumberJSON(cucumber_json_path)  # type: ignore[attr-defined]
+        config.pluginmanager.register(config._bddcucumberjson)  # type: ignore[attr-defined]
 
 
 def unconfigure(config: Config) -> None:
-    xml = getattr(config, "_bddcucumberjson", None)
+    xml = getattr(config, "_bddcucumberjson", None)  # type: ignore[attr-defined]
     if xml is not None:
-        del config._bddcucumberjson
+        del config._bddcucumberjson  # type: ignore[attr-defined]
         config.pluginmanager.unregister(xml)
 
 

src/pytest_bdd/exceptions.py

@@ -15,10 +15,6 @@ class ScenarioNotFound(ScenarioValidationError):
     """Scenario Not Found."""
 
 
-class ExamplesNotValidError(ScenarioValidationError):
-    """Example table is not valid."""
-
-
 class StepDefinitionNotFoundError(Exception):
     """Step definition not found."""
 
@@ -41,7 +37,7 @@ def __init__(self, message, line, line_content, filename):
         self.filename = filename
 
     def __str__(self):
-        return f"{self.__class__.__name__}: {self.message}\nLine number: {self.line}\nLine: {self.line_content}\nFile: {self.filename}"
+        return f"{self.message}\nLine number: {self.line}\nLine: {self.line_content}\nFile: {self.filename}"
 
 
 class FeatureError(GherkinParseError):
@@ -52,33 +48,17 @@ class BackgroundError(GherkinParseError):
     pass
 
 
-class ScenarioOutlineError(GherkinParseError):
-    pass
-
-
 class ScenarioError(GherkinParseError):
     pass
 
 
-class ExamplesError(GherkinParseError):
-    pass
-
-
 class StepError(GherkinParseError):
     pass
 
 
-class TagError(GherkinParseError):
-    pass
-
-
 class RuleError(GherkinParseError):
     pass
 
 
-class DocStringError(GherkinParseError):
-    pass
-
-
 class TokenError(GherkinParseError):
     pass

src/pytest_bdd/feature.py

@@ -65,17 +65,16 @@ def get_features(paths: list[str], **kwargs) -> list[Feature]:
     :return: `list` of `Feature` objects.
     """
     seen_names = set()
-    features = []
+    _features = []
     for path in paths:
         if path not in seen_names:
             seen_names.add(path)
             if os.path.isdir(path):
-                features.extend(
-                    get_features(glob.iglob(os.path.join(path, "**", "*.feature"), recursive=True), **kwargs)
-                )
+                file_paths = list(glob.iglob(os.path.join(path, "**", "*.feature"), recursive=True))
+                _features.extend(get_features(file_paths, **kwargs))
             else:
                 base, name = os.path.split(path)
                 feature = get_feature(base, name, **kwargs)
-                features.append(feature)
-    features.sort(key=lambda feature: feature.name or feature.filename)
-    return features
+                _features.append(feature)
+    _features.sort(key=lambda _feature: _feature.name or _feature.filename)
+    return _features

src/pytest_bdd/generation.py

@@ -7,7 +7,7 @@
 from typing import TYPE_CHECKING, cast
 
 from _pytest._io import TerminalWriter
-from mako.lookup import TemplateLookup
+from mako.lookup import TemplateLookup  # type: ignore
 
 from .compat import getfixturedefs
 from .feature import get_features
@@ -181,11 +181,11 @@ def _show_missing_code_main(config: Config, session: Session) -> None:
     features, scenarios, steps = parse_feature_files(config.option.features)
 
     for item in session.items:
-        if scenario := getattr(item.obj, "__scenario__", None):
+        if scenario := getattr(item.obj, "__scenario__", None):  # type: ignore
             if scenario in scenarios:
                 scenarios.remove(scenario)
             for step in scenario.steps:
-                if _find_step_fixturedef(fm, item, step=step):
+                if _find_step_fixturedef(fm, item, step=step):  # type: ignore
                     try:
                         steps.remove(step)
                     except ValueError:

src/pytest_bdd/gherkin_parser.py

@@ -5,16 +5,15 @@
 import textwrap
 import typing
 from dataclasses import dataclass, field
-from typing import Any, Dict, List, Optional
+from typing import Any
 
-from gherkin.errors import CompositeParserException
-from gherkin.parser import Parser
-from gherkin.token_scanner import TokenScanner
+from gherkin.errors import CompositeParserException  # type: ignore
+from gherkin.parser import Parser  # type: ignore
 
 from . import exceptions
 
 if typing.TYPE_CHECKING:
-    from typing import Self
+    from typing_extensions import Self
 
 
 ERROR_PATTERNS = [
@@ -33,41 +32,21 @@
         exceptions.BackgroundError,
         "Multiple 'Background' sections detected. Only one 'Background' is allowed per feature.",
     ),
-    (
-        re.compile(r"expected:.*got 'Scenario Outline.*'"),
-        exceptions.ScenarioOutlineError,
-        "'Scenario Outline' requires steps before 'Examples'.",
-    ),
     (
         re.compile(r"expected:.*got 'Scenario.*'"),
         exceptions.ScenarioError,
-        "Misplaced or incorrect 'Scenario' keyword. Ensure it's correctly placed.",
-    ),
-    (
-        re.compile(r"expected:.*got 'Examples.*'"),
-        exceptions.ExamplesError,
-        "'Examples' must follow a valid 'Scenario Outline' and contain table rows.",
+        "Misplaced or incorrect 'Scenario' keyword. Ensure it's correctly placed. There might be a missing Feature section.",
     ),
     (
         re.compile(r"expected:.*got 'Given.*'"),
         exceptions.StepError,
         "Improper step keyword detected. Ensure correct order and indentation for steps (Given, When, Then, etc.).",
     ),
-    (
-        re.compile(r"expected:.*got 'TagLine.*'"),
-        exceptions.TagError,
-        "Tags are misplaced. They should be directly above features, scenarios, or outlines.",
-    ),
     (
         re.compile(r"expected:.*got 'Rule.*'"),
         exceptions.RuleError,
         "Misplaced or incorrectly formatted 'Rule'. Ensure it follows the feature structure.",
     ),
-    (
-        re.compile(r"expected:.*got 'DocString.*'"),
-        exceptions.DocStringError,
-        'DocString must be enclosed in triple quotes ("""). Ensure proper formatting.',
-    ),
     (
         re.compile(r"expected:.*got '.*'"),
         exceptions.TokenError,
@@ -196,7 +175,7 @@ class Scenario:
     description: str
     steps: list[Step]
     tags: list[Tag]
-    examples: list[DataTable] | None = field(default_factory=list)
+    examples: list[DataTable] = field(default_factory=list)
 
     @classmethod
     def from_dict(cls, data: dict[str, Any]) -> Self:
@@ -208,7 +187,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.get("examples", [])],
+            examples=[DataTable.from_dict(example) for example in data["examples"]],
         )
 
 
@@ -309,37 +288,38 @@ def _to_raw_string(normal_string: str) -> str:
     return normal_string.replace("\\", "\\\\")
 
 
-def get_gherkin_document(abs_filename: str = None, encoding: str = "utf-8") -> GherkinDocument:
+def get_gherkin_document(abs_filename: str, encoding: str = "utf-8") -> GherkinDocument:
     with open(abs_filename, encoding=encoding) as f:
         feature_file_text = f.read()
 
     try:
-        gherkin_data = Parser().parse(TokenScanner(feature_file_text))
+        gherkin_data = Parser().parse(feature_file_text)
     except CompositeParserException as e:
         message = e.args[0]
         line = e.errors[0].location["line"]
         line_content = linecache.getline(abs_filename, e.errors[0].location["line"]).rstrip("\n")
         filename = abs_filename
-        gherkin_error_handler = GherkinParserErrorHandler()
-        gherkin_error_handler(message, line, line_content, filename)
+        handle_gherkin_parser_error(message, line, line_content, filename, e)
         # If no patterns matched, raise a generic GherkinParserError
-        raise exceptions.GherkinParseError(f"Unknown parsing error: {message}", line, line_content, filename)
+        raise exceptions.GherkinParseError(f"Unknown parsing error: {message}", line, line_content, filename) from e
 
     # At this point, the `gherkin_data` should be valid if no exception was raised
     return GherkinDocument.from_dict(gherkin_data)
 
 
-class GherkinParserErrorHandler:
-    """Parses raw Gherkin parser errors and converts them to human-readable exceptions."""
-
-    def __call__(self, raw_error: str, line: int, line_content: str, filename: str):
-        """Map the error message to a specific exception type and raise it."""
-        # Split the raw_error into individual lines
-        error_lines = raw_error.splitlines()
-
-        # Check each line against all error patterns
-        for error_line in error_lines:
-            for pattern, exception_class, message in ERROR_PATTERNS:
-                if pattern.search(error_line):
-                    # If a match is found, raise the corresponding exception with the formatted message
+def handle_gherkin_parser_error(
+    raw_error: str, line: int, line_content: str, filename: str, original_exception: Exception | None = None
+):
+    """Map the error message to a specific exception type and raise it."""
+    # Split the raw_error into individual lines
+    error_lines = raw_error.splitlines()
+
+    # Check each line against all error patterns
+    for error_line in error_lines:
+        for pattern, exception_class, message in ERROR_PATTERNS:
+            if pattern.search(error_line):
+                # If a match is found, raise the corresponding exception with the formatted message
+                if original_exception:
+                    raise exception_class(message, line, line_content, filename) from original_exception
+                else:
                     raise exception_class(message, line, line_content, filename)

src/pytest_bdd/gherkin_terminal_reporter.py

@@ -43,7 +43,7 @@ def configure(config: Config) -> None:
             raise Exception("gherkin-terminal-reporter is not compatible with 'xdist' plugin.")
 
 
-class GherkinTerminalReporter(TerminalReporter):
+class GherkinTerminalReporter(TerminalReporter):  # type: ignore
     def __init__(self, config: Config) -> None:
         super().__init__(config)
 

src/pytest_bdd/parser.py

@@ -7,6 +7,7 @@
 from dataclasses import dataclass, field
 from typing import Any, Dict, Iterable, List, Mapping, Optional, Sequence
 
+from .exceptions import StepError
 from .gherkin_parser import Background as GherkinBackground
 from .gherkin_parser import Feature as GherkinFeature
 from .gherkin_parser import GherkinDocument
@@ -347,8 +348,7 @@ def get_step_type(keyword: str) -> str | None:
             "then": THEN,
         }.get(keyword)
 
-    @staticmethod
-    def parse_steps(steps_data: list[GherkinStep]) -> list[Step]:
+    def parse_steps(self, steps_data: list[GherkinStep]) -> list[Step]:
         """Parse a list of step data into Step objects.
 
         Args:
@@ -357,22 +357,39 @@ def parse_steps(steps_data: list[GherkinStep]) -> list[Step]:
         Returns:
             List[Step]: A list of Step objects.
         """
+
+        def get_step_content(_gherkin_step):
+            step_name = strip_comments(_gherkin_step.text)
+            if _gherkin_step.docString:
+                step_name = f"{step_name}\n{_gherkin_step.docString.content}"
+            return step_name
+
+        if not steps_data:
+            return []
+
+        first_step = steps_data[0]
+        if first_step.keyword.lower() not in STEP_TYPES:
+            raise StepError(
+                message=f"First step in a scenario or background must start with 'Given', 'When' or 'Then', but got {first_step.keyword}.",
+                line=first_step.location.line,
+                line_content=get_step_content(first_step),
+                filename=self.abs_filename,
+            )
+
         steps = []
-        current_type = None
-        for step_data in steps_data:
-            name = strip_comments(step_data.text)
-            if step_data.docString:
-                name = f"{name}\n{step_data.docString.content}"
-            keyword = step_data.keyword.lower()
+        current_type = first_step.keyword.lower()
+        for step in steps_data:
+            name = get_step_content(step)
+            keyword = step.keyword.lower()
             if keyword in STEP_TYPES:
                 current_type = keyword
             steps.append(
                 Step(
                     name=name,
                     type=current_type,
-                    indent=step_data.location.column - 1,
-                    line_number=step_data.location.line,
-                    keyword=step_data.keyword.title(),
+                    indent=step.location.column - 1,
+                    line_number=step.location.line,
+                    keyword=step.keyword.title(),
                 )
             )
         return steps
@@ -404,12 +421,14 @@ def parse_scenario(self, scenario_data: GherkinScenario, feature: Feature) -> Sc
                 line_number=example_data.location.line,
                 name=example_data.name,
             )
-            param_names = [cell.value for cell in example_data.tableHeader.cells]
-            examples.set_param_names(param_names)
-            for row in example_data.tableBody:
-                values = [cell.value or "" for cell in row.cells]
-                examples.add_example(values)
-            scenario.examples = examples
+            if example_data.tableHeader is not None:
+                param_names = [cell.value for cell in example_data.tableHeader.cells]
+                examples.set_param_names(param_names)
+                if example_data.tableBody is not None:
+                    for row in example_data.tableBody:
+                        values = [cell.value or "" for cell in row.cells]
+                        examples.add_example(values)
+                    scenario.examples = examples
 
         return scenario
 
@@ -431,7 +450,7 @@ def _parse_feature_file(self) -> GherkinDocument:
         """
         return get_gherkin_document(self.abs_filename, self.encoding)
 
-    def parse(self):
+    def parse(self) -> Feature:
         gherkin_doc: GherkinDocument = self._parse_feature_file()
         feature_data: GherkinFeature = gherkin_doc.feature
         feature = Feature(