schemathesis 3.25.6__py3-none-any.whl → 4.0.0a1__py3-none-any.whl

schemathesis/pytest/lazy.py

@@ -0,0 +1,273 @@
+from __future__ import annotations
+
+from contextlib import nullcontext
+from dataclasses import dataclass, field
+from inspect import signature
+from typing import TYPE_CHECKING, Any, Callable, Generator, Type
+
+import pytest
+from hypothesis.core import HypothesisHandle
+from pytest_subtests import SubTests
+
+from schemathesis.core.errors import InvalidSchema
+from schemathesis.core.result import Ok
+from schemathesis.filters import FilterSet, FilterValue, MatcherFunc, RegexValue, is_deprecated
+from schemathesis.generation.hypothesis.builder import get_all_tests
+from schemathesis.generation.hypothesis.given import (
+    GivenArgsMark,
+    GivenInput,
+    GivenKwargsMark,
+    given_proxy,
+    is_given_applied,
+    merge_given_args,
+    validate_given_args,
+)
+from schemathesis.generation.overrides import Override, OverrideMark, check_no_override_mark
+from schemathesis.pytest.control_flow import fail_on_no_matches
+from schemathesis.schemas import BaseSchema
+
+if TYPE_CHECKING:
+    from _pytest.fixtures import FixtureRequest
+
+    from schemathesis.schemas import APIOperation
+
+
+@dataclass
+class LazySchema:
+    fixture_name: str
+    filter_set: FilterSet = field(default_factory=FilterSet)
+
+    def include(
+        self,
+        func: MatcherFunc | None = None,
+        *,
+        name: FilterValue | None = None,
+        name_regex: str | None = None,
+        method: FilterValue | None = None,
+        method_regex: str | None = None,
+        path: FilterValue | None = None,
+        path_regex: str | None = None,
+        tag: FilterValue | None = None,
+        tag_regex: RegexValue | None = None,
+        operation_id: FilterValue | None = None,
+        operation_id_regex: RegexValue | None = None,
+    ) -> LazySchema:
+        """Include only operations that match the given filters."""
+        filter_set = self.filter_set.clone()
+        filter_set.include(
+            func,
+            name=name,
+            name_regex=name_regex,
+            method=method,
+            method_regex=method_regex,
+            path=path,
+            path_regex=path_regex,
+            tag=tag,
+            tag_regex=tag_regex,
+            operation_id=operation_id,
+            operation_id_regex=operation_id_regex,
+        )
+        return self.__class__(fixture_name=self.fixture_name, filter_set=filter_set)
+
+    def exclude(
+        self,
+        func: MatcherFunc | None = None,
+        *,
+        name: FilterValue | None = None,
+        name_regex: str | None = None,
+        method: FilterValue | None = None,
+        method_regex: str | None = None,
+        path: FilterValue | None = None,
+        path_regex: str | None = None,
+        tag: FilterValue | None = None,
+        tag_regex: RegexValue | None = None,
+        operation_id: FilterValue | None = None,
+        operation_id_regex: RegexValue | None = None,
+        deprecated: bool = False,
+    ) -> LazySchema:
+        """Exclude operations that match the given filters."""
+        filter_set = self.filter_set.clone()
+        if deprecated:
+            if func is None:
+                func = is_deprecated
+            else:
+                filter_set.exclude(is_deprecated)
+        filter_set.exclude(
+            func,
+            name=name,
+            name_regex=name_regex,
+            method=method,
+            method_regex=method_regex,
+            path=path,
+            path_regex=path_regex,
+            tag=tag,
+            tag_regex=tag_regex,
+            operation_id=operation_id,
+            operation_id_regex=operation_id_regex,
+        )
+        return self.__class__(fixture_name=self.fixture_name, filter_set=filter_set)
+
+    def parametrize(self) -> Callable:
+        def wrapper(test_func: Callable) -> Callable:
+            if is_given_applied(test_func):
+                # The user wrapped the test function with `@schema.given`
+                # These args & kwargs go as extra to the underlying test generator
+                given_args = GivenArgsMark.get(test_func)
+                given_kwargs = GivenKwargsMark.get(test_func)
+                assert given_args is not None
+                assert given_kwargs is not None
+                test_function = validate_given_args(test_func, given_args, given_kwargs)
+                if test_function is not None:
+                    return test_function
+                given_kwargs = merge_given_args(test_func, given_args, given_kwargs)
+                del given_args
+            else:
+                given_kwargs = {}
+
+            def wrapped_test(request: FixtureRequest) -> None:
+                """The actual test, which is executed by pytest."""
+                __tracebackhide__ = True
+                schema = get_schema(
+                    request=request,
+                    name=self.fixture_name,
+                    test_function=test_func,
+                    filter_set=self.filter_set,
+                )
+                fixtures = get_fixtures(test_func, request, given_kwargs)
+                # Changing the node id is required for better reporting - the method and path will appear there
+                node_id = request.node._nodeid
+                settings = getattr(wrapped_test, "_hypothesis_internal_use_settings", None)
+
+                as_strategy_kwargs: Callable[[APIOperation], dict[str, Any]] | None = None
+
+                override = OverrideMark.get(test_func)
+                if override is not None:
+
+                    def as_strategy_kwargs(_operation: APIOperation) -> dict[str, Any]:
+                        nonlocal override
+
+                        return {
+                            location: entry for location, entry in override.for_operation(_operation).items() if entry
+                        }
+
+                tests = list(
+                    get_all_tests(
+                        schema=schema,
+                        test_func=test_func,
+                        settings=settings,
+                        generation_config=schema.generation_config,
+                        as_strategy_kwargs=as_strategy_kwargs,
+                        given_kwargs=given_kwargs,
+                    )
+                )
+                if not tests:
+                    fail_on_no_matches(node_id)
+                request.session.testscollected += len(tests)
+                suspend_capture_ctx = _get_capturemanager(request)
+                subtests = SubTests(request.node.ihook, suspend_capture_ctx, request)
+                for result in tests:
+                    if isinstance(result, Ok):
+                        operation, sub_test = result.ok()
+                        subtests.item._nodeid = f"{node_id}[{operation.method.upper()} {operation.full_path}]"
+                        run_subtest(operation, fixtures, sub_test, subtests)
+                    else:
+                        _schema_error(subtests, result.err(), node_id)
+                subtests.item._nodeid = node_id
+
+            wrapped_test = pytest.mark.usefixtures(self.fixture_name)(wrapped_test)
+            _copy_marks(test_func, wrapped_test)
+
+            # Needed to prevent a failure when settings are applied to the test function
+            wrapped_test.is_hypothesis_test = True  # type: ignore
+            wrapped_test.hypothesis = HypothesisHandle(test_func, wrapped_test, given_kwargs)  # type: ignore
+
+            return wrapped_test
+
+        return wrapper
+
+    def given(self, *args: GivenInput, **kwargs: GivenInput) -> Callable:
+        return given_proxy(*args, **kwargs)
+
+    def override(
+        self,
+        *,
+        query: dict[str, str] | None = None,
+        headers: dict[str, str] | None = None,
+        cookies: dict[str, str] | None = None,
+        path_parameters: dict[str, str] | None = None,
+    ) -> Callable[[Callable], Callable]:
+        """Override Open API parameters with fixed values."""
+
+        def _add_override(test: Callable) -> Callable:
+            check_no_override_mark(test)
+            override = Override(
+                query=query or {}, headers=headers or {}, cookies=cookies or {}, path_parameters=path_parameters or {}
+            )
+            OverrideMark.set(test, override)
+            return test
+
+        return _add_override
+
+
+def _copy_marks(source: Callable, target: Callable) -> None:
+    marks = getattr(source, "pytestmark", [])
+    # Pytest adds this attribute in `usefixtures`
+    target.pytestmark.extend(marks)  # type: ignore
+
+
+def _get_capturemanager(request: FixtureRequest) -> Generator | Type[nullcontext]:
+    capturemanager = request.node.config.pluginmanager.get_plugin("capturemanager")
+    if capturemanager is not None:
+        return capturemanager.global_and_fixture_disabled
+    return nullcontext
+
+
+def run_subtest(operation: APIOperation, fixtures: dict[str, Any], sub_test: Callable, subtests: SubTests) -> None:
+    """Run the given subtest with pytest fixtures."""
+    __tracebackhide__ = True
+
+    with subtests.test(label=operation.label):
+        sub_test(**fixtures)
+
+
+SEPARATOR = "\n===================="
+
+
+def _schema_error(subtests: SubTests, error: InvalidSchema, node_id: str) -> None:
+    """Run a failing test, that will show the underlying problem."""
+    sub_test = error.as_failing_test_function()
+    # `full_path` is always available in this case
+    kwargs = {"path": error.full_path}
+    if error.method:
+        kwargs["method"] = error.method.upper()
+    subtests.item._nodeid = _get_partial_node_name(node_id, **kwargs)
+    __tracebackhide__ = True
+    with subtests.test(**kwargs):
+        sub_test()
+
+
+def _get_partial_node_name(node_id: str, **kwargs: Any) -> str:
+    """Make a test node name for failing tests caused by schema errors."""
+    name = node_id
+    if "method" in kwargs:
+        name += f"[{kwargs['method']} {kwargs['path']}]"
+    else:
+        name += f"[{kwargs['path']}]"
+    return name
+
+
+def get_schema(*, request: FixtureRequest, name: str, filter_set: FilterSet, test_function: Callable) -> BaseSchema:
+    """Loads a schema from the fixture."""
+    schema = request.getfixturevalue(name)
+    if not isinstance(schema, BaseSchema):
+        raise ValueError(f"The given schema must be an instance of BaseSchema, got: {type(schema)}")
+
+    return schema.clone(filter_set=filter_set, test_function=test_function)
+
+
+def get_fixtures(func: Callable, request: FixtureRequest, given_kwargs: dict[str, Any]) -> dict[str, Any]:
+    """Load fixtures, needed for the test function."""
+    sig = signature(func)
+    return {
+        name: request.getfixturevalue(name) for name in sig.parameters if name != "case" and name not in given_kwargs
+    }

schemathesis/pytest/loaders.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from schemathesis.pytest.lazy import LazySchema
+
+
+def from_fixture(name: str) -> LazySchema:
+    from schemathesis.pytest.lazy import LazySchema
+
+    return LazySchema(name)

schemathesis/{extra/pytest_plugin.py → pytest/plugin.py}

@@ -1,55 +1,59 @@
 from __future__ import annotations
 
+import asyncio
 import unittest
-from contextlib import contextmanager
 from functools import partial
-from typing import Any, Callable, Generator, Type, TypeVar, cast
+from typing import TYPE_CHECKING, Any, Callable, Generator, Type, cast
 
 import pytest
-from _pytest import fixtures, nodes
+from _pytest import nodes
 from _pytest.config import hookimpl
-from _pytest.fixtures import FuncFixtureInfo
-from _pytest.nodes import Node
 from _pytest.python import Class, Function, FunctionDefinition, Metafunc, Module, PyCollector
-from hypothesis import reporting
 from hypothesis.errors import InvalidArgument, Unsatisfiable
 from jsonschema.exceptions import SchemaError
 
-from .._dependency_versions import IS_PYTEST_ABOVE_7, IS_PYTEST_ABOVE_8, IS_PYTEST_ABOVE_54
-from .._override import get_override_from_mark
-from ..constants import (
-    GIVEN_AND_EXPLICIT_EXAMPLES_ERROR_MESSAGE,
+from schemathesis.core.control import SkipTest
+from schemathesis.core.errors import (
     RECURSIVE_REFERENCE_ERROR_MESSAGE,
     SERIALIZERS_SUGGESTION_MESSAGE,
-)
-from ..exceptions import (
+    IncorrectUsage,
     InvalidHeadersExample,
-    InvalidRegularExpression,
-    OperationSchemaError,
+    InvalidRegexPattern,
+    InvalidSchema,
     SerializationNotPossible,
-    SkipTest,
-    UsageError,
 )
-from ..internal.result import Ok, Result
-from ..models import APIOperation
-from ..utils import (
-    PARAMETRIZE_MARKER,
-    fail_on_no_matches,
-    get_given_args,
-    get_given_kwargs,
+from schemathesis.core.marks import Mark
+from schemathesis.core.result import Ok, Result
+from schemathesis.generation.hypothesis.given import (
+    GivenArgsMark,
+    GivenKwargsMark,
     is_given_applied,
-    is_schemathesis_test,
     merge_given_args,
     validate_given_args,
 )
+from schemathesis.generation.hypothesis.reporting import ignore_hypothesis_output
+from schemathesis.generation.overrides import OverrideMark
+from schemathesis.pytest.control_flow import fail_on_no_matches
+from schemathesis.schemas import APIOperation
+
+if TYPE_CHECKING:
+    from _pytest.fixtures import FuncFixtureInfo
+
+    from schemathesis.schemas import BaseSchema
+
+GIVEN_AND_EXPLICIT_EXAMPLES_ERROR_MESSAGE = (
+    "Unsupported test setup. Tests using `@schema.given` cannot be combined with explicit schema examples in the same "
+    "function. Separate these tests into distinct functions to avoid conflicts."
+)
+
 
-T = TypeVar("T", bound=Node)
+def _is_schema(value: object) -> bool:
+    from schemathesis.schemas import BaseSchema
 
+    return isinstance(value, BaseSchema)
 
-def create(cls: type[T], *args: Any, **kwargs: Any) -> T:
-    if IS_PYTEST_ABOVE_54:
-        return cls.from_parent(*args, **kwargs)  # type: ignore
-    return cls(*args, **kwargs)
+
+SchemaHandleMark = Mark["BaseSchema"](attr_name="schema", check=_is_schema)
 
 
 class SchemathesisFunction(Function):
@@ -64,21 +68,15 @@ class SchemathesisFunction(Function):
         self.test_function = test_func
         self.test_name = test_name
 
-    if not IS_PYTEST_ABOVE_7:
-        # On pytest 7, `self.obj` is already `partial`
-        def _getobj(self) -> partial:
-            """Tests defined as methods require `self` as the first argument.
-
-            This method is called only for this case.
-            """
-            return partial(self.obj, self.parent.obj)  # type: ignore
-
 
 class SchemathesisCase(PyCollector):
-    def __init__(self, test_function: Callable, *args: Any, **kwargs: Any) -> None:
-        self.given_kwargs: dict[str, Any] | None
-        given_args = get_given_args(test_function)
-        given_kwargs = get_given_kwargs(test_function)
+    def __init__(self, test_function: Callable, schema: BaseSchema, *args: Any, **kwargs: Any) -> None:
+        self.given_kwargs: dict[str, Any]
+        given_args = GivenArgsMark.get(test_function)
+        given_kwargs = GivenKwargsMark.get(test_function)
+
+        assert given_args is not None
+        assert given_kwargs is not None
 
         def _init_with_valid_test(_test_function: Callable, _args: tuple, _kwargs: dict[str, Any]) -> None:
             self.test_function = _test_function
@@ -90,20 +88,18 @@ class SchemathesisCase(PyCollector):
             if failing_test is not None:
                 self.test_function = failing_test
                 self.is_invalid_test = True
-                self.given_kwargs = None
+                self.given_kwargs = {}
             else:
                 _init_with_valid_test(test_function, given_args, given_kwargs)
         else:
             _init_with_valid_test(test_function, given_args, given_kwargs)
-        self.schemathesis_case = getattr(test_function, PARAMETRIZE_MARKER)
+        self.schema = schema
         super().__init__(*args, **kwargs)
 
     def _get_test_name(self, operation: APIOperation) -> str:
-        return f"{self.name}[{operation.verbose_name}]"
+        return f"{self.name}[{operation.label}]"
 
-    def _gen_items(
-        self, result: Result[APIOperation, OperationSchemaError]
-    ) -> Generator[SchemathesisFunction, None, None]:
+    def _gen_items(self, result: Result[APIOperation, InvalidSchema]) -> Generator[SchemathesisFunction, None, None]:
         """Generate all tests for the given API operation.
 
         Could produce more than one test item if
@@ -112,7 +108,7 @@ class SchemathesisCase(PyCollector):
         This implementation is based on the original one in pytest, but with slight adjustments
         to produce tests out of hypothesis ones.
         """
-        from .._hypothesis import create_test
+        from schemathesis.generation.hypothesis.builder import HypothesisTestConfig, create_test
 
         is_trio_test = False
         for mark in getattr(self.test_function, "pytestmark", []):
@@ -125,24 +121,29 @@ class SchemathesisCase(PyCollector):
             if self.is_invalid_test:
                 funcobj = self.test_function
             else:
-                override = get_override_from_mark(self.test_function)
-                as_strategy_kwargs: dict | None
+                override = OverrideMark.get(self.test_function)
                 if override is not None:
                     as_strategy_kwargs = {}
                     for location, entry in override.for_operation(operation).items():
                         if entry:
                             as_strategy_kwargs[location] = entry
                 else:
-                    as_strategy_kwargs = None
+                    as_strategy_kwargs = {}
                 funcobj = create_test(
                     operation=operation,
-                    test=self.test_function,
-                    _given_kwargs=self.given_kwargs,
-                    data_generation_methods=self.schemathesis_case.data_generation_methods,
-                    generation_config=self.schemathesis_case.generation_config,
-                    as_strategy_kwargs=as_strategy_kwargs,
-                    keep_async_fn=is_trio_test,
+                    test_func=self.test_function,
+                    config=HypothesisTestConfig(
+                        given_kwargs=self.given_kwargs,
+                        generation=self.schema.generation_config,
+                        as_strategy_kwargs=as_strategy_kwargs,
+                    ),
                 )
+                if asyncio.iscoroutinefunction(self.test_function):
+                    # `pytest-trio` expects a coroutine function
+                    if is_trio_test:
+                        funcobj.hypothesis.inner_test = self.test_function  # type: ignore
+                    else:
+                        funcobj.hypothesis.inner_test = make_async_test(self.test_function)  # type: ignore
             name = self._get_test_name(operation)
         else:
             error = result.err()
@@ -155,7 +156,9 @@ class SchemathesisCase(PyCollector):
                 name += f"[{error.full_path}]"
 
         cls = self._get_class_parent()
-        definition: FunctionDefinition = create(FunctionDefinition, name=self.name, parent=self.parent, callobj=funcobj)
+        definition: FunctionDefinition = FunctionDefinition.from_parent(
+            name=self.name, parent=self.parent, callobj=funcobj
+        )
         fixturemanager = self.session._fixturemanager
         fixtureinfo = fixturemanager.getfixtureinfo(definition, funcobj, cls)
 
@@ -166,8 +169,7 @@ class SchemathesisCase(PyCollector):
             funcobj = partial(funcobj, self.parent.obj)
 
         if not metafunc._calls:
-            yield create(
-                SchemathesisFunction,
+            yield SchemathesisFunction.from_parent(
                 name=name,
                 parent=self.parent,
                 callobj=funcobj,
@@ -176,15 +178,12 @@ class SchemathesisCase(PyCollector):
                 originalname=self.name,
             )
         else:
-            if not IS_PYTEST_ABOVE_8:
-                fixtures.add_funcarg_pseudo_fixture_def(self.parent, metafunc, fixturemanager)  # type: ignore[arg-type]
             fixtureinfo.prune_dependency_tree()
             for callspec in metafunc._calls:
                 subname = f"{name}[{callspec.id}]"
-                yield create(
-                    SchemathesisFunction,
+                yield SchemathesisFunction.from_parent(
+                    self.parent,
                     name=subname,
-                    parent=self.parent,
                     callspec=callspec,
                     callobj=funcobj,
                     fixtureinfo=fixtureinfo,
@@ -200,13 +199,10 @@ class SchemathesisCase(PyCollector):
     def _parametrize(self, cls: type | None, definition: FunctionDefinition, fixtureinfo: FuncFixtureInfo) -> Metafunc:
         parent = self.getparent(Module)
         module = parent.obj if parent is not None else parent
-        kwargs = {"cls": cls, "module": module}
-        if IS_PYTEST_ABOVE_7:
-            # Avoiding `Metafunc` is quite problematic for now, as there are quite a lot of internals we rely on
-            kwargs["_ispytest"] = True
-        metafunc = Metafunc(definition, fixtureinfo, self.config, **kwargs)
+        # Avoiding `Metafunc` is quite problematic for now, as there are quite a lot of internals we rely on
+        metafunc = Metafunc(definition, fixtureinfo, self.config, cls=cls, module=module, _ispytest=True)
         methods = []
-        if hasattr(module, "pytest_generate_tests"):
+        if module is not None and hasattr(module, "pytest_generate_tests"):
             methods.append(module.pytest_generate_tests)
         if hasattr(cls, "pytest_generate_tests"):
             cls = cast(Type, cls)
@@ -217,13 +213,7 @@ class SchemathesisCase(PyCollector):
     def collect(self) -> list[Function]:  # type: ignore
         """Generate different test items for all API operations available in the given schema."""
         try:
-            items = [
-                item
-                for operation in self.schemathesis_case.get_all_operations(
-                    hooks=getattr(self.test_function, "_schemathesis_hooks", None)
-                )
-                for item in self._gen_items(operation)
-            ]
+            items = [item for operation in self.schema.get_all_operations() for item in self._gen_items(operation)]
             if not items:
                 fail_on_no_matches(self.nodeid)
             return items
@@ -231,37 +221,32 @@ class SchemathesisCase(PyCollector):
             pytest.fail("Error during collection")
 
 
-@hookimpl(hookwrapper=True)  # type:ignore # pragma: no mutate
+def make_async_test(test: Callable) -> Callable:
+    def async_run(*args: Any, **kwargs: Any) -> None:
+        try:
+            loop = asyncio.get_event_loop()
+        except RuntimeError:
+            loop = asyncio.new_event_loop()
+        coro = test(*args, **kwargs)
+        future = asyncio.ensure_future(coro, loop=loop)
+        loop.run_until_complete(future)
+
+    return async_run
+
+
+@hookimpl(hookwrapper=True)  # type:ignore
 def pytest_pycollect_makeitem(collector: nodes.Collector, name: str, obj: Any) -> Generator[None, Any, None]:
     """Switch to a different collector if the test is parametrized marked by schemathesis."""
     outcome = yield
-    if is_schemathesis_test(obj):
-        outcome.force_result(create(SchemathesisCase, parent=collector, test_function=obj, name=name))
-    else:
+    try:
+        schema = SchemaHandleMark.get(obj)
+        assert schema is not None
+        outcome.force_result(SchemathesisCase.from_parent(collector, test_function=obj, name=name, schema=schema))
+    except Exception:
         outcome.get_result()
 
 
-IGNORED_HYPOTHESIS_OUTPUT = ("Falsifying example",)
-
-
-def _should_ignore_entry(value: str) -> bool:
-    return value.startswith(IGNORED_HYPOTHESIS_OUTPUT)
-
-
-def hypothesis_reporter(value: str) -> None:
-    if _should_ignore_entry(value):
-        return
-    reporting.default(value)
-
-
-@contextmanager
-def skip_unnecessary_hypothesis_output() -> Generator:
-    """Avoid printing Hypothesis output that is not necessary in Schemathesis' pytest plugin."""
-    with reporting.with_reporter(hypothesis_reporter):  # type: ignore
-        yield
-
-
-@hookimpl(hookwrapper=True)
+@hookimpl(wrapper=True)
 def pytest_pyfunc_call(pyfuncitem):  # type:ignore
     """It is possible to have a Hypothesis exception in runtime.
 
@@ -269,29 +254,28 @@ def pytest_pyfunc_call(pyfuncitem):  # type:ignore
     """
     from hypothesis_jsonschema._canonicalise import HypothesisRefResolutionError
 
-    from .._hypothesis import (
-        get_invalid_example_headers_mark,
-        get_invalid_regex_mark,
-        get_non_serializable_mark,
-        has_unsatisfied_example_mark,
+    from schemathesis.generation.hypothesis.builder import (
+        InvalidHeadersExampleMark,
+        InvalidRegexMark,
+        NonSerializableMark,
+        UnsatisfiableExampleMark,
     )
 
     __tracebackhide__ = True
     if isinstance(pyfuncitem, SchemathesisFunction):
-        with skip_unnecessary_hypothesis_output():
-            outcome = yield
         try:
-            outcome.get_result()
+            with ignore_hypothesis_output():
+                yield
         except InvalidArgument as exc:
             if "Inconsistent args" in str(exc) and "@example()" in str(exc):
-                raise UsageError(GIVEN_AND_EXPLICIT_EXAMPLES_ERROR_MESSAGE) from None
-            raise OperationSchemaError(exc.args[0]) from None
+                raise IncorrectUsage(GIVEN_AND_EXPLICIT_EXAMPLES_ERROR_MESSAGE) from None
+            raise InvalidSchema(exc.args[0]) from None
         except HypothesisRefResolutionError:
             pytest.skip(RECURSIVE_REFERENCE_ERROR_MESSAGE)
         except (SkipTest, unittest.SkipTest) as exc:
-            if has_unsatisfied_example_mark(pyfuncitem.obj):
+            if UnsatisfiableExampleMark.is_set(pyfuncitem.obj):
                 raise Unsatisfiable("Failed to generate test cases from examples for this API operation") from None
-            non_serializable = get_non_serializable_mark(pyfuncitem.obj)
+            non_serializable = NonSerializableMark.get(pyfuncitem.obj)
             if non_serializable is not None:
                 media_types = ", ".join(non_serializable.media_types)
                 raise SerializationNotPossible(
@@ -299,22 +283,17 @@ def pytest_pyfunc_call(pyfuncitem):  # type:ignore
                     f" unsupported payload media types: {media_types}\n{SERIALIZERS_SUGGESTION_MESSAGE}",
                     media_types=non_serializable.media_types,
                 ) from None
-            invalid_regex = get_invalid_regex_mark(pyfuncitem.obj)
+            invalid_regex = InvalidRegexMark.get(pyfuncitem.obj)
             if invalid_regex is not None:
-                raise InvalidRegularExpression.from_schema_error(invalid_regex, from_examples=True) from None
-            invalid_headers = get_invalid_example_headers_mark(pyfuncitem.obj)
+                raise InvalidRegexPattern.from_schema_error(invalid_regex, from_examples=True) from None
+            invalid_headers = InvalidHeadersExampleMark.get(pyfuncitem.obj)
             if invalid_headers is not None:
                 raise InvalidHeadersExample.from_headers(invalid_headers) from None
             pytest.skip(exc.args[0])
         except SchemaError as exc:
-            raise InvalidRegularExpression.from_schema_error(exc, from_examples=False) from exc
-        except Exception as exc:
-            if hasattr(exc, "__notes__"):
-                exc.__notes__ = [note for note in exc.__notes__ if not _should_ignore_entry(note)]  # type: ignore
-            raise
-        invalid_headers = get_invalid_example_headers_mark(pyfuncitem.obj)
+            raise InvalidRegexPattern.from_schema_error(exc, from_examples=False) from exc
+        invalid_headers = InvalidHeadersExampleMark.get(pyfuncitem.obj)
         if invalid_headers is not None:
             raise InvalidHeadersExample.from_headers(invalid_headers) from None
     else:
-        outcome = yield
-        outcome.get_result()
+        yield