Merge pull request #505 from pytest-dev/add-type-annotations

Add type annotations to the codebase.

Author: youtux

.github/workflows/main.yml

@@ -11,7 +11,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ["3.6", "3.7", "3.8", "3.9", "3.10"]
+        python-version: ["3.7", "3.8", "3.9", "3.10"]
 
     steps:
     - uses: actions/checkout@v2
@@ -24,6 +24,10 @@ jobs:
         python -m pip install --upgrade pip
         pip install -U setuptools
         pip install tox tox-gh-actions codecov
+    - name: Type checking
+      continue-on-error: true
+      run: |
+        tox -e mypy
     - name: Test with tox
       run: |
         tox

.pre-commit-config.yaml

@@ -22,4 +22,10 @@ repos:
     rev: v2.31.0
     hooks:
     -   id: pyupgrade
-        args: [--py37-plus]
+        args: ["--py37-plus"]
+# TODO: Enable mypy checker when the checks succeed
+#-   repo: https://github.com/pre-commit/mirrors-mypy
+#    rev: v0.931
+#    hooks:
+#    -   id: mypy
+#        additional_dependencies: [types-setuptools]

CHANGES.rst

@@ -13,6 +13,8 @@ This release introduces breaking changes in order to be more in line with the of
 - Drop support of python 3.6, pytest 4 (elchupanebrej)
 - Step definitions can have "yield" statements again (4.0 release broke it). They will be executed as normal fixtures: code after the yield is executed during teardown of the test. (youtux)
 - Scenario outlines unused example parameter validation is removed (olegpidsadnyi)
+- Add type decorations
+- ``pytest_bdd.parsers.StepParser`` now is an Abstract Base Class. Subclasses must make sure to implement the abstract methods.
 
 
 

pyproject.toml

@@ -10,3 +10,13 @@ target-version = ["py37", "py38", "py39", "py310"]
 profile = "black"
 line_length = 120
 multi_line_output = 3
+
+[tool.mypy]
+python_version = "3.7"
+warn_return_any = true
+warn_unused_configs = true
+files = "pytest_bdd/**/*.py"
+
+[[tool.mypy.overrides]]
+module = ["parse", "parse_type", "glob2"]
+ignore_missing_imports = true

pytest_bdd/__init__.py

@@ -1,8 +1,9 @@
 """pytest-bdd public API."""
+from __future__ import annotations
 
 from pytest_bdd.scenario import scenario, scenarios
 from pytest_bdd.steps import given, then, when
 
 __version__ = "6.0.0"
 
-__all__ = [given.__name__, when.__name__, then.__name__, scenario.__name__, scenarios.__name__]
+__all__ = ["given", "when", "then", "scenario", "scenarios"]

pytest_bdd/cucumber_json.py

@@ -1,12 +1,22 @@
 """Cucumber json output formatter."""
+from __future__ import annotations
 
 import json
 import math
 import os
 import time
+import typing
 
+if typing.TYPE_CHECKING:
+    from typing import Any
 
-def add_options(parser):
+    from _pytest.config import Config
+    from _pytest.config.argparsing import Parser
+    from _pytest.reports import TestReport
+    from _pytest.terminal import TerminalReporter
+
+
+def add_options(parser: Parser) -> None:
     """Add pytest-bdd options."""
     group = parser.getgroup("bdd", "Cucumber JSON")
     group.addoption(
@@ -20,15 +30,15 @@ def add_options(parser):
     )
 
 
-def configure(config):
+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)
 
 
-def unconfigure(config):
+def unconfigure(config: Config) -> None:
     xml = getattr(config, "_bddcucumberjson", None)
     if xml is not None:
         del config._bddcucumberjson
@@ -39,22 +49,19 @@ class LogBDDCucumberJSON:
 
     """Logging plugin for cucumber like json output."""
 
-    def __init__(self, logfile):
+    def __init__(self, logfile: str) -> None:
         logfile = os.path.expanduser(os.path.expandvars(logfile))
         self.logfile = os.path.normpath(os.path.abspath(logfile))
-        self.features = {}
-
-    def append(self, obj):
-        self.features[-1].append(obj)
+        self.features: dict[str, dict] = {}
 
-    def _get_result(self, step, report, error_message=False):
+    def _get_result(self, step: dict[str, Any], report: TestReport, error_message: bool = False) -> dict[str, Any]:
         """Get scenario test run result.
 
         :param step: `Step` step we get result for
         :param report: pytest `Report` object
         :return: `dict` in form {"status": "<passed|failed|skipped>", ["error_message": "<error_message>"]}
         """
-        result = {}
+        result: dict[str, Any] = {}
         if report.passed or not step["failed"]:  # ignore setup/teardown
             result = {"status": "passed"}
         elif report.failed and step["failed"]:
@@ -64,7 +71,7 @@ def _get_result(self, step, report, error_message=False):
         result["duration"] = int(math.floor((10**9) * step["duration"]))  # nanosec
         return result
 
-    def _serialize_tags(self, item):
+    def _serialize_tags(self, item: dict[str, Any]) -> list[dict[str, Any]]:
         """Serialize item's tags.
 
         :param item: json-serialized `Scenario` or `Feature`.
@@ -78,7 +85,7 @@ def _serialize_tags(self, item):
         """
         return [{"name": tag, "line": item["line_number"] - 1} for tag in item["tags"]]
 
-    def pytest_runtest_logreport(self, report):
+    def pytest_runtest_logreport(self, report: TestReport) -> None:
         try:
             scenario = report.scenario
         except AttributeError:
@@ -89,7 +96,7 @@ def pytest_runtest_logreport(self, report):
             # skip if there isn't a result or scenario has no steps
             return
 
-        def stepmap(step):
+        def stepmap(step: dict[str, Any]) -> dict[str, Any]:
             error_message = False
             if step["failed"] and not scenario.setdefault("failed", False):
                 scenario["failed"] = True
@@ -130,12 +137,12 @@ def stepmap(step):
             }
         )
 
-    def pytest_sessionstart(self):
+    def pytest_sessionstart(self) -> None:
         self.suite_start_time = time.time()
 
-    def pytest_sessionfinish(self):
+    def pytest_sessionfinish(self) -> None:
         with open(self.logfile, "w", encoding="utf-8") as logfile:
             logfile.write(json.dumps(list(self.features.values())))
 
-    def pytest_terminal_summary(self, terminalreporter):
-        terminalreporter.write_sep("-", "generated json file: %s" % (self.logfile))
+    def pytest_terminal_summary(self, terminalreporter: TerminalReporter) -> None:
+        terminalreporter.write_sep("-", f"generated json file: {self.logfile}")

pytest_bdd/exceptions.py

@@ -1,4 +1,5 @@
 """pytest-bdd Exceptions."""
+from __future__ import annotations
 
 
 class ScenarioIsDecoratorOnly(Exception):
@@ -30,6 +31,6 @@ class FeatureError(Exception):
 
     message = "{0}.\nLine number: {1}.\nLine: {2}.\nFile: {3}"
 
-    def __str__(self):
+    def __str__(self) -> str:
         """String representation."""
         return self.message.format(*self.args)

pytest_bdd/feature.py

@@ -23,15 +23,16 @@
 :note: There are no multiline steps, the description of the step must fit in
 one line.
 """
+from __future__ import annotations
+
 import os.path
-import typing
 
 import glob2
 
 from .parser import Feature, parse_feature
 
 # Global features dictionary
-features: typing.Dict[str, Feature] = {}
+features: dict[str, Feature] = {}
 
 
 def get_feature(base_path: str, filename: str, encoding: str = "utf-8") -> Feature:
@@ -56,7 +57,7 @@ def get_feature(base_path: str, filename: str, encoding: str = "utf-8") -> Featu
     return feature
 
 
-def get_features(paths: typing.List[str], **kwargs) -> typing.List[Feature]:
+def get_features(paths: list[str], **kwargs) -> list[Feature]:
     """Get features for given paths.
 
     :param list paths: `list` of paths (file or dirs)

pytest_bdd/generation.py

@@ -1,7 +1,9 @@
 """pytest-bdd missing test code generation."""
+from __future__ import annotations
 
 import itertools
 import os.path
+from typing import TYPE_CHECKING, cast
 
 import py
 from mako.lookup import TemplateLookup
@@ -11,10 +13,21 @@
 from .steps import get_step_fixture_name
 from .types import STEP_TYPES
 
+if TYPE_CHECKING:
+    from typing import Any, Sequence
+
+    from _pytest.config import Config
+    from _pytest.config.argparsing import Parser
+    from _pytest.fixtures import FixtureDef, FixtureManager
+    from _pytest.main import Session
+    from _pytest.python import Function
+
+    from .parser import Feature, ScenarioTemplate, Step
+
 template_lookup = TemplateLookup(directories=[os.path.join(os.path.dirname(__file__), "templates")])
 
 
-def add_options(parser):
+def add_options(parser: Parser) -> None:
     """Add pytest-bdd options."""
     group = parser.getgroup("bdd", "Generation")
 
@@ -35,34 +48,36 @@ def add_options(parser):
     )
 
 
-def cmdline_main(config):
+def cmdline_main(config: Config) -> int | None:
     """Check config option to show missing code."""
     if config.option.generate_missing:
         return show_missing_code(config)
+    return None  # Make mypy happy
 
 
-def generate_code(features, scenarios, steps):
+def generate_code(features: list[Feature], scenarios: list[ScenarioTemplate], steps: list[Step]) -> str:
     """Generate test code for the given filenames."""
     grouped_steps = group_steps(steps)
     template = template_lookup.get_template("test.py.mak")
-    return template.render(
+    code = template.render(
         features=features,
         scenarios=scenarios,
         steps=grouped_steps,
         make_python_name=make_python_name,
         make_python_docstring=make_python_docstring,
         make_string_literal=make_string_literal,
     )
+    return cast(str, code)
 
 
-def show_missing_code(config):
+def show_missing_code(config: Config) -> int:
     """Wrap pytest session to show missing code."""
     from _pytest.main import wrap_session
 
     return wrap_session(config, _show_missing_code_main)
 
 
-def print_missing_code(scenarios, steps):
+def print_missing_code(scenarios: list[ScenarioTemplate], steps: list[Step]) -> None:
     """Print missing code with TerminalWriter."""
     tw = py.io.TerminalWriter()
     scenario = step = None
@@ -108,14 +123,10 @@ def print_missing_code(scenarios, steps):
     tw.write(code)
 
 
-def _find_step_fixturedef(fixturemanager, item, name, type_):
-    """Find step fixturedef.
-
-    :param request: PyTest Item object.
-    :param step: `Step`.
-
-    :return: Step function.
-    """
+def _find_step_fixturedef(
+    fixturemanager: FixtureManager, item: Function, name: str, type_: str
+) -> Sequence[FixtureDef[Any]] | None:
+    """Find step fixturedef."""
     step_fixture_name = get_step_fixture_name(name, type_)
     fixturedefs = fixturemanager.getfixturedefs(step_fixture_name, item.nodeid)
     if fixturedefs is not None:
@@ -127,7 +138,7 @@ def _find_step_fixturedef(fixturemanager, item, name, type_):
     return None
 
 
-def parse_feature_files(paths, **kwargs):
+def parse_feature_files(paths: list[str], **kwargs: Any) -> tuple[list[Feature], list[ScenarioTemplate], list[Step]]:
     """Parse feature files of given paths.
 
     :param paths: `list` of paths (file or dirs)
@@ -146,7 +157,7 @@ def parse_feature_files(paths, **kwargs):
     return features, scenarios, steps
 
 
-def group_steps(steps):
+def group_steps(steps: list[Step]) -> list[Step]:
     """Group steps by type."""
     steps = sorted(steps, key=lambda step: step.type)
     seen_steps = set()
@@ -161,7 +172,7 @@ def group_steps(steps):
     return grouped_steps
 
 
-def _show_missing_code_main(config, session):
+def _show_missing_code_main(config: Config, session: Session) -> None:
     """Preparing fixture duplicates for output."""
     tw = py.io.TerminalWriter()
     session.perform_collect()

pytest_bdd/gherkin_terminal_reporter.py

@@ -1,7 +1,18 @@
+from __future__ import annotations
+
+import typing
+
 from _pytest.terminal import TerminalReporter
 
+if typing.TYPE_CHECKING:
+    from typing import Any
+
+    from _pytest.config import Config
+    from _pytest.config.argparsing import Parser
+    from _pytest.reports import TestReport
+
 
-def add_options(parser):
+def add_options(parser: Parser) -> None:
     group = parser.getgroup("terminal reporting", "reporting", after="general")
     group._addoption(
         "--gherkin-terminal-reporter",
@@ -12,7 +23,7 @@ def add_options(parser):
     )
 
 
-def configure(config):
+def configure(config: Config) -> None:
     if config.option.gherkin_terminal_reporter:
         # Get the standard terminal reporter plugin and replace it with our
         current_reporter = config.pluginmanager.getplugin("terminalreporter")
@@ -33,17 +44,17 @@ def configure(config):
 
 
 class GherkinTerminalReporter(TerminalReporter):
-    def __init__(self, config):
+    def __init__(self, config: Config) -> None:
         super().__init__(config)
 
-    def pytest_runtest_logreport(self, report):
+    def pytest_runtest_logreport(self, report: TestReport) -> Any:
         rep = report
         res = self.config.hook.pytest_report_teststatus(report=rep, config=self.config)
         cat, letter, word = res
 
         if not letter and not word:
             # probably passed setup/teardown
-            return
+            return None
 
         if isinstance(word, tuple):
             word, word_markup = word
@@ -88,3 +99,4 @@ def pytest_runtest_logreport(self, report):
             else:
                 return super().pytest_runtest_logreport(rep)
         self.stats.setdefault(cat, []).append(rep)
+        return None