Handle multiple parsers connected to a step function

Author: youtux

pytest_bdd/scenario.py

@@ -43,20 +43,19 @@ def find_argumented_step_fixture_name(
     # happens to be that _arg2fixturedefs is changed during the iteration so we use a copy
     for fixturename, fixturedefs in list(fixturemanager._arg2fixturedefs.items()):
         for fixturedef in fixturedefs:
-            parser = getattr(fixturedef.func, "parser", None)
-            if parser is None:
-                continue
-            match = parser.is_matching(name)
-            if not match:
-                continue
-
-            parser_name = get_step_fixture_name(parser.name, type_)
-            if request:
-                try:
-                    request.getfixturevalue(parser_name)
-                except FixtureLookupError:
+            parsers = getattr(fixturedef.func, "_pytest_bdd_parsers", [])
+            for parser in parsers:
+                match = parser.is_matching(name)
+                if not match:
                     continue
-            return parser_name
+
+                parser_name = get_step_fixture_name(parser.name, type_)
+                if request:
+                    try:
+                        request.getfixturevalue(parser_name)
+                    except FixtureLookupError:
+                        continue
+                return parser_name
     return None
 
 
@@ -107,12 +106,16 @@ def _execute_step_function(request: FixtureRequest, scenario: Scenario, step: St
         converters = getattr(step_func, "converters", {})
         kwargs = {}
 
-        parser = getattr(step_func, "parser", None)
-        if parser is not None:
+        parsers = getattr(step_func, "_pytest_bdd_parsers", [])
+
+        for parser in parsers:
+            if not parser.is_matching(step.name):
+                continue
             for arg, value in parser.parse_arguments(step.name).items():
                 if arg in converters:
                     value = converters[arg](value)
                 kwargs[arg] = value
+            break
 
         kwargs = {arg: kwargs[arg] if arg in kwargs else request.getfixturevalue(arg) for arg in get_args(step_func)}
         kw["step_func_args"] = kwargs

pytest_bdd/steps.py

@@ -43,7 +43,7 @@ def given_beautiful_article(article):
 
 from .parsers import get_parser
 from .types import GIVEN, THEN, WHEN
-from .utils import get_caller_module_locals
+from .utils import get_caller_module_locals, setdefault
 
 if typing.TYPE_CHECKING:
     from typing import Any, Callable
@@ -124,6 +124,8 @@ def decorator(func: Callable) -> Callable:
         parser_instance = get_parser(step_name)
         parsed_step_name = parser_instance.name
 
+        # TODO: Try to not attach to both step_func and lazy_step_func
+
         step_func.__name__ = str(parsed_step_name)
 
         def lazy_step_func() -> Callable:
@@ -135,7 +137,9 @@ def lazy_step_func() -> Callable:
         # Preserve the docstring
         lazy_step_func.__doc__ = func.__doc__
 
-        step_func.parser = lazy_step_func.parser = parser_instance
+        setdefault(step_func, "_pytest_bdd_parsers", []).append(parser_instance)
+        setdefault(lazy_step_func, "_pytest_bdd_parsers", []).append(parser_instance)
+
         if converters:
             step_func.converters = lazy_step_func.converters = converters
 

pytest_bdd/utils.py

@@ -4,16 +4,18 @@
 import base64
 import pickle
 import re
-import typing
 from inspect import getframeinfo, signature
 from sys import _getframe
+from typing import TYPE_CHECKING, TypeVar
 
-if typing.TYPE_CHECKING:
+if TYPE_CHECKING:
     from typing import Any, Callable
 
     from _pytest.config import Config
     from _pytest.pytester import RunResult
 
+T = TypeVar("T")
+
 CONFIG_STACK: list[Config] = []
 
 
@@ -69,3 +71,12 @@ def collect_dumped_objects(result: RunResult) -> list:
     stdout = result.stdout.str()  # pytest < 6.2, otherwise we could just do str(result.stdout)
     payloads = re.findall(rf"{_DUMP_START}(.*?){_DUMP_END}", stdout)
     return [pickle.loads(base64.b64decode(payload)) for payload in payloads]
+
+
+def setdefault(obj: object, name: str, default: T) -> T:
+    """Just like dict.setdefault, but for objects."""
+    try:
+        return getattr(obj, name)
+    except AttributeError:
+        setattr(obj, name, default)
+        return default

tests/feature/test_steps.py

@@ -72,6 +72,58 @@ def check_results(results):
     result.assert_outcomes(passed=1, failed=0)
 
 
+def test_step_function_can_be_decorated_multiple_times(testdir):
+    testdir.makefile(
+        ".feature",
+        steps=textwrap.dedent(
+            """\
+            Feature: Steps decoration
+
+                Scenario: Step function can be decorated multiple times
+                    Given there is a foo with value 42
+                    And there is a second foo with value 43
+                    When I do nothing
+                    And I do nothing again
+                    Then I make no mistakes
+                    And I make no mistakes again
+
+            """
+        ),
+    )
+    testdir.makepyfile(
+        textwrap.dedent(
+            """\
+        from pytest_bdd import given, when, then, scenario, parsers
+
+        @scenario("steps.feature", "Step function can be decorated multiple times")
+        def test_steps():
+            pass
+
+
+        @given(parsers.parse("there is a foo with value {value}"), target_fixture="foo")
+        @given(parsers.parse("there is a second foo with value {value}"), target_fixture="second_foo")
+        def foo(value):
+            return value
+
+
+        @when("I do nothing")
+        @when("I do nothing again")
+        def do_nothing():
+            pass
+
+
+        @then("I make no mistakes")
+        @then("I make no mistakes again")
+        def no_errors():
+            assert True
+
+        """
+        )
+    )
+    result = testdir.runpytest()
+    result.assert_outcomes(passed=1, failed=0)
+
+
 def test_all_steps_can_provide_fixtures(testdir):
     """Test that given/when/then can all provide fixtures."""
     testdir.makefile(