Add missing type annotations, and require all files to be typed

Author: youtux

pyproject.toml

@@ -94,6 +94,7 @@ python_version = "3.8"
 warn_return_any = true
 warn_unused_configs = true
 files = "src/pytest_bdd/**/*.py"
+disallow_untyped_defs = true
 
 [[tool.mypy.overrides]]
 module = ["parse", "parse_type"]

src/pytest_bdd/exceptions.py

@@ -26,7 +26,7 @@ class NoScenariosFound(Exception):
 class GherkinParseError(Exception):
     """Base class for all Gherkin parsing errors."""
 
-    def __init__(self, message: str, line: int, line_content: str, filename: str):
+    def __init__(self, message: str, line: int, line_content: str, filename: str) -> None:
         super().__init__(message)
         self.message = message
         self.line = line

src/pytest_bdd/feature.py

@@ -57,7 +57,7 @@ def get_feature(base_path: str, filename: str, encoding: str = "utf-8") -> Featu
     return feature
 
 
-def get_features(paths: list[str], **kwargs) -> list[Feature]:
+def get_features(paths: list[str], encoding: str = "utf-8") -> list[Feature]:
     """Get features for given paths.
 
     :param list paths: `list` of paths (file or dirs)
@@ -71,10 +71,10 @@ def get_features(paths: list[str], **kwargs) -> list[Feature]:
             seen_names.add(path)
             if os.path.isdir(path):
                 file_paths = list(glob.iglob(os.path.join(path, "**", "*.feature"), recursive=True))
-                _features.extend(get_features(file_paths, **kwargs))
+                _features.extend(get_features(file_paths, encoding=encoding))
             else:
                 base, name = os.path.split(path)
-                feature = get_feature(base, name, **kwargs)
+                feature = get_feature(base, name, encoding=encoding)
                 _features.append(feature)
     _features.sort(key=lambda _feature: _feature.name or _feature.filename)
     return _features

src/pytest_bdd/gherkin_parser.py

@@ -309,7 +309,7 @@ def get_gherkin_document(abs_filename: str, encoding: str = "utf-8") -> GherkinD
 
 def handle_gherkin_parser_error(
     raw_error: str, line: int, line_content: str, filename: str, original_exception: Exception | None = 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()

src/pytest_bdd/hooks.py

@@ -1,40 +1,71 @@
 from __future__ import annotations
 
+from collections.abc import Callable
+
 import pytest
+from _pytest.fixtures import FixtureRequest
+
+from pytest_bdd.parser import Feature, Scenario, Step
 
 """Pytest-bdd pytest hooks."""
 
 
-def pytest_bdd_before_scenario(request, feature, scenario):
+def pytest_bdd_before_scenario(request: FixtureRequest, feature: Feature, scenario: Scenario) -> object:
     """Called before scenario is executed."""
 
 
-def pytest_bdd_after_scenario(request, feature, scenario):
+def pytest_bdd_after_scenario(request: FixtureRequest, feature: Feature, scenario: Scenario) -> object:
     """Called after scenario is executed."""
 
 
-def pytest_bdd_before_step(request, feature, scenario, step, step_func):
+def pytest_bdd_before_step(
+    request: FixtureRequest, feature: Feature, scenario: Scenario, step: Step, step_func: Callable[..., object]
+) -> object:
     """Called before step function is set up."""
 
 
-def pytest_bdd_before_step_call(request, feature, scenario, step, step_func, step_func_args):
+def pytest_bdd_before_step_call(
+    request: FixtureRequest,
+    feature: Feature,
+    scenario: Scenario,
+    step: Step,
+    step_func: Callable[..., object],
+    step_func_args: dict[str, object],
+) -> object:
     """Called before step function is executed."""
 
 
-def pytest_bdd_after_step(request, feature, scenario, step, step_func, step_func_args):
+def pytest_bdd_after_step(
+    request: FixtureRequest,
+    feature: Feature,
+    scenario: Scenario,
+    step: Step,
+    step_func: Callable[..., object],
+    step_func_args: dict[str, object],
+) -> object:
     """Called after step function is successfully executed."""
 
 
-def pytest_bdd_step_error(request, feature, scenario, step, step_func, step_func_args, exception):
+def pytest_bdd_step_error(
+    request: FixtureRequest,
+    feature: Feature,
+    scenario: Scenario,
+    step: Step,
+    step_func: Callable[..., object],
+    step_func_args: dict[str, object],
+    exception: Exception,
+) -> object:
     """Called when step function failed to execute."""
 
 
-def pytest_bdd_step_func_lookup_error(request, feature, scenario, step, exception):
+def pytest_bdd_step_func_lookup_error(
+    request: FixtureRequest, feature: Feature, scenario: Scenario, step: Step, exception: Exception
+) -> object:
     """Called when step lookup failed."""
 
 
 @pytest.hookspec(firstresult=True)
-def pytest_bdd_apply_tag(tag, function):
+def pytest_bdd_apply_tag(tag: str, function: Callable[..., object]) -> object:
     """Apply a tag (from a ``.feature`` file) to the given scenario.
 
     The default implementation does the equivalent of

src/pytest_bdd/parser.py

@@ -358,7 +358,7 @@ def parse_steps(self, steps_data: list[GherkinStep]) -> list[Step]:
             List[Step]: A list of Step objects.
         """
 
-        def get_step_content(_gherkin_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}"

src/pytest_bdd/scenario.py

@@ -17,7 +17,7 @@
 import logging
 import os
 import re
-from typing import TYPE_CHECKING, Any, Callable, Iterable, Iterator, List, Optional, TypeVar, cast
+from typing import TYPE_CHECKING, Any, Callable, Iterable, Iterator, List, TypeVar, cast
 
 import pytest
 from _pytest.fixtures import FixtureDef, FixtureManager, FixtureRequest, call_fixture_func
@@ -151,7 +151,7 @@ def get_fixture_path(fixture_def: FixtureDef) -> list[str]:
         del fixturemanager._arg2fixturedefs[bdd_name]
 
 
-def get_step_function(request, step: Step) -> StepFunctionContext | None:
+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.