schemathesis 3.39.16__py3-none-any.whl → 4.0.0__py3-none-any.whl

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

@@ -1,49 +1,61 @@
 from __future__ import annotations
 
+import asyncio
 import unittest
-from contextlib import contextmanager
 from functools import partial
 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.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
-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,
+    format_exception,
 )
-from ..internal.result import Ok, Result
-from ..utils import (
-    PARAMETRIZE_MARKER,
-    fail_on_no_matches,
-    get_given_args,
-    get_given_kwargs,
+from schemathesis.core.failures import FailureGroup
+from schemathesis.core.marks import Mark
+from schemathesis.core.result import Ok, Result
+from schemathesis.generation import overrides
+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.pytest.control_flow import fail_on_no_matches
+from schemathesis.schemas import APIOperation
 
 if TYPE_CHECKING:
     from _pytest.fixtures import FuncFixtureInfo
 
-    from ..models import APIOperation
+    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."
+)
+
+
+def _is_schema(value: object) -> bool:
+    from schemathesis.schemas import BaseSchema
+
+    return isinstance(value, BaseSchema)
+
+
+SchemaHandleMark = Mark["BaseSchema"](attr_name="schema", check=_is_schema)
 
 
 class SchemathesisFunction(Function):
@@ -58,21 +70,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
@@ -84,20 +90,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
@@ -106,7 +110,15 @@ 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.checks import load_all_checks
+        from schemathesis.generation.hypothesis.builder import (
+            HypothesisTestConfig,
+            HypothesisTestMode,
+            create_test,
+            make_async_test,
+        )
+
+        load_all_checks()
 
         is_trio_test = False
         for mark in getattr(self.test_function, "pytestmark", []):
@@ -119,34 +131,57 @@ 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
+                as_strategy_kwargs = {}
+
+                auth = self.schema.config.auth_for(operation=operation)
+                if auth is not None:
+                    from requests.auth import _basic_auth_str
+
+                    as_strategy_kwargs["headers"] = {"Authorization": _basic_auth_str(*auth)}
+                headers = self.schema.config.headers_for(operation=operation)
+                if headers:
+                    as_strategy_kwargs["headers"] = headers
+
+                override = overrides.for_operation(operation=operation, config=self.schema.config)
                 if override is not None:
-                    as_strategy_kwargs = {}
-                    for location, entry in override.for_operation(operation).items():
+                    for location, entry in override.items():
                         if entry:
                             as_strategy_kwargs[location] = entry
-                else:
-                    as_strategy_kwargs = None
+                modes = []
+                phases = self.schema.config.phases_for(operation=operation)
+                if phases.examples.enabled:
+                    modes.append(HypothesisTestMode.EXAMPLES)
+                if phases.fuzzing.enabled:
+                    modes.append(HypothesisTestMode.FUZZING)
+                if phases.coverage.enabled:
+                    modes.append(HypothesisTestMode.COVERAGE)
+
                 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(
+                        modes=modes,
+                        settings=self.schema.config.get_hypothesis_settings(operation=operation),
+                        given_kwargs=self.given_kwargs,
+                        project=self.schema.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()
             funcobj = error.as_failing_test_function()
             name = self.name
-            # `full_path` is always available in this case
             if error.method:
-                name += f"[{error.method.upper()} {error.full_path}]"
+                name += f"[{error.method.upper()} {error.path}]"
             else:
-                name += f"[{error.full_path}]"
+                name += f"[{error.path}]"
 
         cls = self._get_class_parent()
         definition: FunctionDefinition = FunctionDefinition.from_parent(
@@ -171,8 +206,6 @@ 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}]"
@@ -194,11 +227,8 @@ 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 module is not None and hasattr(module, "pytest_generate_tests"):
             methods.append(module.pytest_generate_tests)
@@ -211,13 +241,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
@@ -225,34 +249,34 @@ class SchemathesisCase(PyCollector):
             pytest.fail("Error during collection")
 
 
-@hookimpl(hookwrapper=True)  # type:ignore # pragma: no mutate
+@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(SchemathesisCase.from_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)
+@pytest.hookimpl(tryfirst=True)  # type: ignore[misc]
+def pytest_exception_interact(node: Function, call: pytest.CallInfo, report: pytest.TestReport) -> None:
+    if call.excinfo and call.excinfo.type is FailureGroup:
+        tb_entries = list(call.excinfo.traceback)
+        total_frames = len(tb_entries)
 
+        # Keep internal Schemathesis frames + one extra one from the caller
+        skip_frames = 0
+        for i in range(total_frames - 1, -1, -1):
+            entry = tb_entries[i]
 
-def hypothesis_reporter(value: str) -> None:
-    if _should_ignore_entry(value):
-        return
-    reporting.default(value)
-
+            if not str(entry.path).endswith("schemathesis/generation/case.py"):
+                skip_frames = i
+                break
 
-@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
+        report.longrepr = "".join(format_exception(call.excinfo.value, with_traceback=True, skip_frames=skip_frames))
 
 
 @hookimpl(wrapper=True)
@@ -263,28 +287,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):
         try:
-            with skip_unnecessary_hypothesis_output():
+            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(
@@ -292,20 +316,16 @@ 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:

schemathesis/python/asgi.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from starlette_testclient import TestClient as ASGIClient
+
+
+def get_client(app: Any) -> ASGIClient:
+    from starlette_testclient import TestClient as ASGIClient
+
+    return ASGIClient(app)

schemathesis/python/wsgi.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from werkzeug import Client
+
+
+def get_client(app: Any) -> Client:
+    from werkzeug import Client
+
+    return Client(app)