Implement async steps.

Author: maafy6

src/pytest_bdd/steps.py

@@ -36,7 +36,11 @@ def _(article):
 """
 from __future__ import annotations
 
+import asyncio
 import enum
+import functools
+import inspect
+from contextlib import contextmanager
 from dataclasses import dataclass, field
 from itertools import count
 from typing import Any, Callable, Iterable, TypeVar
@@ -66,6 +70,7 @@ class StepFunctionContext:
     parser: StepParser
     converters: dict[str, Callable[..., Any]] = field(default_factory=dict)
     target_fixture: str | None = None
+    is_async: bool = False
 
 
 def get_step_fixture_name(step: Step) -> str:
@@ -86,6 +91,7 @@ def given(
                        {<param_name>: <converter function>}.
     :param target_fixture: Target fixture name to replace by steps definition function.
     :param stacklevel: Stack level to find the caller frame. This is used when injecting the step definition fixture.
+    :param is_async: True if the step is asynchronous. (Default: False)
 
     :return: Decorator function for the step.
     """
@@ -105,6 +111,7 @@ def when(
                        {<param_name>: <converter function>}.
     :param target_fixture: Target fixture name to replace by steps definition function.
     :param stacklevel: Stack level to find the caller frame. This is used when injecting the step definition fixture.
+    :param is_async: True if the step is asynchronous. (Default: False)
 
     :return: Decorator function for the step.
     """
@@ -124,6 +131,7 @@ def then(
                        {<param_name>: <converter function>}.
     :param target_fixture: Target fixture name to replace by steps definition function.
     :param stacklevel: Stack level to find the caller frame. This is used when injecting the step definition fixture.
+    :param is_async: True if the step is asynchronous. (Default: False)
 
     :return: Decorator function for the step.
     """
@@ -144,6 +152,7 @@ def step(
     :param converters: Optional step arguments converters mapping.
     :param target_fixture: Optional fixture name to replace by step definition.
     :param stacklevel: Stack level to find the caller frame. This is used when injecting the step definition fixture.
+    :param is_async: True if the step is asynchronous. (Default: False)
 
     :return: Decorator function for the step.
 
@@ -159,6 +168,11 @@ def step(
     def decorator(func: TCallable) -> TCallable:
         parser = get_parser(name)
 
+        if inspect.isasyncgenfunction(func):
+            func = wrap_asyncgen(func)
+        elif inspect.iscoroutinefunction(func):
+            func = wrap_coroutine(func)
+
         context = StepFunctionContext(
             type=type_,
             step_func=func,
@@ -177,11 +191,79 @@ def step_function_marker() -> StepFunctionContext:
             f"{StepNamePrefix.step_def.value}_{type_ or '*'}_{parser.name}", seen=caller_locals.keys()
         )
         caller_locals[fixture_step_name] = pytest.fixture(name=fixture_step_name)(step_function_marker)
+
         return func
 
     return decorator
 
 
+def _synchronize(func: Callable, async_wrapper: Callable) -> Callable:
+    """Provide a synchronous wrapper for an async function or generator.
+
+    :param func: The async function / generator to wrap.
+    :param async_wrapper: A function taking an event loop and either a
+        coroutine or an async_generator (the result of calling func)
+        and returning the result.
+
+    :returns: The wrapped async function.
+    """
+
+    @functools.wraps(func)
+    def _wrapper(*args, **kwargs):
+        try:
+            loop, created = asyncio.get_running_loop(), False
+        except RuntimeError:
+            loop, created = asyncio.get_event_loop_policy().new_event_loop(), True
+
+        try:
+            yield async_wrapper(loop, func(*args, **kwargs))
+        except:
+            raise
+        finally:
+            if created:
+                loop.close()
+
+    return _wrapper
+
+
+def wrap_asyncgen(func: Callable) -> Callable:
+    """Wrapper for an async_generator function.
+
+    :param func: The function to wrap.
+
+    :returns: The wrapped function. The wrapped function will raise ValueError
+        if the generator yields more than once.
+    """
+
+    def _wrapper(loop: asyncio.events.AbstractEventLoop, async_obj):
+        result = loop.run_until_complete(async_obj.__anext__())
+        try:
+            loop.run_until_complete(async_obj.__anext__())
+        except StopAsyncIteration:
+            pass
+        else:
+            msg = "Async genetator should yield only once."
+            raise ValueError(msg)
+
+        return result
+
+    return _synchronize(func, _wrapper)
+
+
+def wrap_coroutine(func: Callable) -> Callable:
+    """Wrapper for a coroutine function.
+
+    :param func: The function to wrap.
+
+    :returns: The wrapped function.
+    """
+
+    def _wrapper(loop: asyncio.events.AbstractEventLoop, async_obj):
+        return loop.run_until_complete(async_obj)
+
+    return _synchronize(func, _wrapper)
+
+
 def find_unique_name(name: str, seen: Iterable[str]) -> str:
     """Find unique name among a set of strings.