Add possibility to register imported steps (#63)

* Add the possibility to register imported steps
* Add test step definition hierarchy overlapping from pytest-dev#544

Author: elchupanebrej

CHANGES.rst

@@ -8,6 +8,10 @@ Planned
 - Extra support of official parser
    - https://github.com/pytest-dev/pytest-bdd/issues/502
 
+1.2.2
+-----
+- Add possibility to register imported steps
+
 1.2.0
 -----
 - Make liberal step definitions conform with

README.rst

@@ -156,6 +156,30 @@ default author.
             Given I'm the admin
             And there's an article
 
+
+Importing steps
+---------------
+Just import steps into test module or `conftest.py` is not enough to be found by pytest-bdd. To use steps from other
+module there are few possibilities:
+
+- Register steps from module:
+
+.. code-block:: python
+
+    import module_with_steps
+
+    step.from_module(module_with_steps)
+
+- Import steps and register them from locals:
+
+.. code-block:: python
+
+    from module_with_steps import given_a, when_b, then_c
+
+    step.from_locals()
+
+- Build step_registry fixture and register imported steps there
+
 Liberal step decorator
 ----------------------
 Sometimes you want use same step for all types of steps without re-defining alias;

pytest_bdd/steps.py

@@ -38,7 +38,7 @@ def given_beautiful_article(article):
 
 import warnings
 from contextlib import suppress
-from typing import Any, Callable, Iterable, Iterator, Sequence
+from typing import Any, Callable, Iterable, Iterator, Sequence, cast
 from warnings import warn
 
 import pytest
@@ -49,7 +49,7 @@ def given_beautiful_article(article):
 from pytest_bdd.model import Feature, Scenario, Step
 from pytest_bdd.parsers import StepParser, get_parser
 from pytest_bdd.typing.pytest import Config, Parser, TypeAlias
-from pytest_bdd.utils import get_caller_module_locals
+from pytest_bdd.utils import deepattrgetter, get_caller_module_locals, setdefaultattr
 from pytest_bdd.warning_types import PytestBDDStepDefinitionWarning
 
 
@@ -302,16 +302,16 @@ def find_step_definition_matches(
                     with suppress(AttributeError):
                         yield from StepHandler.Matcher.find_step_definition_matches(registry.parent, matchers)
 
-    @attrs(auto_attribs=True)
+    @attrs(auto_attribs=True, eq=False)
     class Definition:
         func: Callable
         type_: str | None
         parser: StepParser
-        converters: dict[str, Any]
-        params_fixtures_mapping: dict[str, str]
+        converters: dict[str, Callable]
+        params_fixtures_mapping: set[str] | dict[str, str] | Any
         param_defaults: dict
         target_fixtures: list[str]
-        liberal: bool
+        liberal: Any | None
 
         def get_parameters(self, step: Step):
             parsed_arguments = self.parser.parse_arguments(step.name) or {}
@@ -322,43 +322,64 @@ def get_parameters(self, step: Step):
 
     @attrs
     class Registry:
-        registry: list[StepHandler.Definition] = attrib(default=Factory(list))
+        registry: set[StepHandler.Definition] = attrib(default=Factory(set))
         parent: StepHandler.Registry = attrib(default=None, init=False)
 
         @classmethod
-        def register_step(
-            cls,
-            caller_locals: dict,
-            func,
-            type_,
-            parserlike,
-            converters,
-            params_fixtures_mapping,
-            param_defaults,
-            target_fixtures,
-            liberal,
-        ):
+        def setdefault_step_registry_fixture(cls, caller_locals: dict):
             if "step_registry" not in caller_locals.keys():
                 built_registry = cls()
-                caller_locals["step_registry"] = built_registry.bind_pytest_bdd_step_registry_fixture()
-
-            registry: StepHandler.Registry = caller_locals["step_registry"].__registry__
-
-            parser = get_parser(parserlike)
-            registry.registry.append(
-                StepHandler.Definition(  # type: ignore[call-arg]
-                    func=func,
-                    type_=type_,
-                    parser=parser,
-                    converters=converters,
-                    params_fixtures_mapping=params_fixtures_mapping,
-                    param_defaults=param_defaults,
-                    target_fixtures=target_fixtures,
-                    liberal=liberal,
-                )
-            )
+                caller_locals["step_registry"] = built_registry.fixture
+            return caller_locals["step_registry"]
+
+        @classmethod
+        def register_step_definition(cls, step_definition, caller_locals: dict):
+            fixture = cls.setdefault_step_registry_fixture(caller_locals=caller_locals)
+            fixture.__registry__.registry.add(step_definition)
+
+        @classmethod
+        def register_steps(cls, *step_funcs, caller_locals: dict):
+            for step_func in step_funcs:
+                for step_definition in step_func.__pytest_bdd_step_definitions__:
+                    cls.register_step_definition(step_definition, caller_locals=caller_locals)
+
+        @classmethod
+        def register_steps_from_locals(cls, caller_locals=None, steps=None):
+            if caller_locals is None:
+                caller_locals = get_caller_module_locals(depth=2)
+
+            def registrable_steps():
+                for name, obj in caller_locals.items():
+                    if hasattr(obj, "__pytest_bdd_step_definitions__") and (
+                        steps is None or any((name in steps, obj in steps))
+                    ):
+                        yield obj
+
+            cls.register_steps(*registrable_steps(), caller_locals=caller_locals)
 
-        def bind_pytest_bdd_step_registry_fixture(self):
+        @classmethod
+        def register_steps_from_module(cls, module, caller_locals=None, steps=None):
+            if caller_locals is None:
+                caller_locals = get_caller_module_locals(depth=2)
+
+            def registrable_steps():
+                # module items
+                for name, obj in module.__dict__.items():
+                    if hasattr(obj, "__pytest_bdd_step_definitions__") and (
+                        steps is None or any((name in steps, obj in steps))
+                    ):
+                        yield obj
+                # module registry items
+                for obj in deepattrgetter("__registry__.registry", default=None)(module.__dict__.get("step_registry"))[
+                    0
+                ]:
+                    if steps is None or obj.func in steps:
+                        yield obj.func
+
+            cls.register_steps(*set(registrable_steps()), caller_locals=caller_locals)
+
+        @property
+        def fixture(self):
             @pytest.fixture
             def step_registry(step_registry):
                 self.parent = step_registry
@@ -376,10 +397,10 @@ def decorator_builder(
         step_parserlike: Any,
         converters: dict[str, Callable] | None = None,
         target_fixture: str | None = None,
-        target_fixtures: list[str] = None,
+        target_fixtures: list[str] | None = None,
         params_fixtures_mapping: set[str] | dict[str, str] | Any = True,
         param_defaults: dict | None = None,
-        liberal: bool | None = None,
+        liberal: Any | None = None,
     ) -> Callable:
         """StepHandler decorator for the type and the name.
 
@@ -414,17 +435,29 @@ def decorator(step_func: Callable) -> Callable:
 
             :param function step_func: StepHandler definition function
             """
-            StepHandler.Registry.register_step(
-                caller_locals=get_caller_module_locals(depth=2),
+
+            step_definiton = StepHandler.Definition(  # type: ignore[call-arg]
                 func=step_func,
                 type_=step_type,
-                parserlike=step_parserlike,
-                converters=converters,
+                parser=get_parser(step_parserlike),
+                converters=cast(dict, converters),
                 params_fixtures_mapping=params_fixtures_mapping,
-                param_defaults=param_defaults,
-                target_fixtures=target_fixtures,
+                param_defaults=cast(dict, param_defaults),
+                target_fixtures=cast(list, target_fixtures),
                 liberal=liberal,
             )
+
+            setdefaultattr(step_func, "__pytest_bdd_step_definitions__", value_factory=set).add(step_definiton)
+
+            StepHandler.Registry.register_step_definition(
+                step_definition=step_definiton,
+                caller_locals=get_caller_module_locals(depth=2),
+            )
+
             return step_func
 
         return decorator
+
+
+step.from_locals = StepHandler.Registry.register_steps_from_locals  # type: ignore[attr-defined]
+step.from_module = StepHandler.Registry.register_steps_from_module  # type: ignore[attr-defined]

pytest_bdd/typing/__init__.py

@@ -4,9 +4,10 @@
 import sys
 
 if sys.version_info >= (3, 8):
-    from typing import Protocol, runtime_checkable
+    from typing import Literal, Protocol, runtime_checkable
 else:
-    from typing_extensions import Protocol, runtime_checkable
+    from typing_extensions import Literal, Protocol, runtime_checkable
 
+assert Literal
 assert Protocol
 assert runtime_checkable

pytest_bdd/utils.py

@@ -6,6 +6,7 @@
 import re
 from collections import defaultdict
 from contextlib import nullcontext, suppress
+from enum import Enum
 from functools import partial
 from inspect import getframeinfo, signature
 from itertools import tee
@@ -17,6 +18,7 @@
 from marshmallow import post_load
 
 from pytest_bdd.const import ALPHA_REGEX, PYTHON_REPLACE_REGEX
+from pytest_bdd.typing import Literal
 from pytest_bdd.typing.pytest import FixtureDef
 
 if TYPE_CHECKING:  # pragma: no cover
@@ -239,6 +241,20 @@ def _():
     return fn
 
 
+class EMPTY(Enum):
+    EMPTY = 1
+
+
+def setdefaultattr(obj, key, value: Literal[EMPTY.EMPTY] | Any = EMPTY, value_factory: None | Callable = None):
+    if value is not EMPTY and value_factory is not None:
+        raise ValueError("Both 'value' and 'value_factory' were specified")
+    if not hasattr(obj, key):
+        if value_factory is not None:
+            value = value_factory()
+        setattr(obj, key, value)
+    return getattr(obj, key, value)
+
+
 def make_python_name(string: str) -> str:
     """Make python attribute name out of a given string."""
     string = re.sub(PYTHON_REPLACE_REGEX, "", string.replace(" ", "_"))

setup.cfg

@@ -7,7 +7,7 @@ author = Oleg Pidsadnyi, Anatoly Bubenkov and others
 license = MIT license
 author_email = [email protected]
 url = https://github.com/elchupanebrej/pytest-bdd-ng
-version = 1.2.1
+version = 1.2.2
 classifiers =
     Development Status :: 4 - Beta
     Intended Audience :: Developers