schemathesis 3.25.5__py3-none-any.whl → 3.39.7__py3-none-any.whl

schemathesis/cli/reporting.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+from itertools import groupby
+from typing import TYPE_CHECKING, Callable, Generator, Iterator
+
+import click
+
+from ..exceptions import RuntimeErrorType
+from ..runner.serialization import SerializedCheck, deduplicate_failures
+
+if TYPE_CHECKING:
+    from ..code_samples import CodeSampleStyle
+
+TEST_CASE_ID_TITLE = "Test Case ID"
+
+
+def group_by_case(
+    checks: list[SerializedCheck], code_sample_style: CodeSampleStyle
+) -> Generator[tuple[str, Iterator[SerializedCheck]], None, None]:
+    checks = deduplicate_failures(checks)
+    checks = sorted(checks, key=lambda c: _by_unique_key(c, code_sample_style))
+    for (sample, _, _), gen in groupby(checks, lambda c: _by_unique_key(c, code_sample_style)):
+        yield (sample, gen)
+
+
+def _by_unique_key(check: SerializedCheck, code_sample_style: CodeSampleStyle) -> tuple[str, int, str]:
+    return (
+        code_sample_style.generate(
+            method=check.example.method,
+            url=check.example.url,
+            body=check.example.deserialize_body(),
+            headers=check.example.headers,
+            verify=check.example.verify,
+            extra_headers=check.example.extra_headers,
+        ),
+        0 if not check.response else check.response.status_code,
+        "SCHEMATHESIS-INTERNAL-NO-RESPONSE"
+        if not check.response
+        else check.response.body or "SCHEMATHESIS-INTERNAL-EMPTY-BODY",
+    )
+
+
+def split_traceback(traceback: str) -> list[str]:
+    return [entry for entry in traceback.splitlines() if entry]
+
+
+def bold(option: str) -> str:
+    return click.style(option, bold=True)
+
+
+def get_runtime_error_suggestion(error_type: RuntimeErrorType, bold: Callable[[str], str] = bold) -> str | None:
+    DISABLE_SSL_SUGGESTION = f"Bypass SSL verification with {bold('`--request-tls-verify=false`')}."
+    DISABLE_SCHEMA_VALIDATION_SUGGESTION = (
+        f"Bypass validation using {bold('`--validate-schema=false`')}. Caution: May cause unexpected errors."
+    )
+
+    def _format_health_check_suggestion(label: str) -> str:
+        return f"Bypass this health check using {bold(f'`--hypothesis-suppress-health-check={label}`')}."
+
+    RUNTIME_ERROR_SUGGESTIONS = {
+        RuntimeErrorType.CONNECTION_SSL: DISABLE_SSL_SUGGESTION,
+        RuntimeErrorType.HYPOTHESIS_DEADLINE_EXCEEDED: (
+            f"Adjust the deadline using {bold('`--hypothesis-deadline=MILLIS`')} or "
+            f"disable with {bold('`--hypothesis-deadline=None`')}."
+        ),
+        RuntimeErrorType.HYPOTHESIS_UNSATISFIABLE: "Examine the schema for inconsistencies and consider simplifying it.",
+        RuntimeErrorType.SCHEMA_BODY_IN_GET_REQUEST: DISABLE_SCHEMA_VALIDATION_SUGGESTION,
+        RuntimeErrorType.SCHEMA_INVALID_REGULAR_EXPRESSION: "Ensure your regex is compatible with Python's syntax.\n"
+        "For guidance, visit: https://docs.python.org/3/library/re.html",
+        RuntimeErrorType.HYPOTHESIS_UNSUPPORTED_GRAPHQL_SCALAR: "Define a custom strategy for it.\n"
+        "For guidance, visit: https://schemathesis.readthedocs.io/en/stable/graphql.html#custom-scalars",
+        RuntimeErrorType.HYPOTHESIS_HEALTH_CHECK_DATA_TOO_LARGE: _format_health_check_suggestion("data_too_large"),
+        RuntimeErrorType.HYPOTHESIS_HEALTH_CHECK_FILTER_TOO_MUCH: _format_health_check_suggestion("filter_too_much"),
+        RuntimeErrorType.HYPOTHESIS_HEALTH_CHECK_TOO_SLOW: _format_health_check_suggestion("too_slow"),
+        RuntimeErrorType.HYPOTHESIS_HEALTH_CHECK_LARGE_BASE_EXAMPLE: _format_health_check_suggestion(
+            "large_base_example"
+        ),
+    }
+    return RUNTIME_ERROR_SUGGESTIONS.get(error_type)

schemathesis/cli/sanitization.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
@@ -18,3 +19,8 @@ class SanitizationHandler(EventHandler):
                 sanitize_serialized_check(check)
             for interaction in event.result.interactions:
                 sanitize_serialized_interaction(interaction)
+        elif isinstance(event, events.AfterStatefulExecution):
+            for check in event.result.checks:
+                sanitize_serialized_check(check)
+            for interaction in event.result.interactions:
+                sanitize_serialized_interaction(interaction)

schemathesis/code_samples.py

@@ -1,15 +1,17 @@
 from __future__ import annotations
+
 from enum import Enum
 from functools import lru_cache
 from shlex import quote
 from typing import TYPE_CHECKING
 
 from .constants import SCHEMATHESIS_TEST_CASE_HEADER
-from .types import Headers
 
 if TYPE_CHECKING:
     from requests.structures import CaseInsensitiveDict
 
+    from .types import Headers
+
 
 @lru_cache
 def get_excluded_headers() -> CaseInsensitiveDict:
@@ -119,9 +121,9 @@ def _generate_requests(
     url = _escape_single_quotes(url)
     command = f"requests.{method.lower()}('{url}'"
     if body:
-        command += f", data={repr(body)}"
+        command += f", data={body!r}"
     if headers:
-        command += f", headers={repr(headers)}"
+        command += f", headers={headers!r}"
     if not verify:
         command += ", verify=False"
     command += ")"

schemathesis/constants.py

@@ -1,4 +1,5 @@
 from importlib import metadata
+
 from .types import NotSet
 
 try:

schemathesis/contrib/openapi/__init__.py

@@ -1,4 +1,4 @@
-from . import formats, fill_missing_examples
+from . import fill_missing_examples, formats
 
 
 def install() -> None:

schemathesis/contrib/openapi/fill_missing_examples.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
+
 from typing import TYPE_CHECKING
+
 from ...hooks import HookContext, register, unregister
 
 if TYPE_CHECKING:
@@ -16,7 +18,7 @@ def uninstall() -> None:
 
 def before_add_examples(context: HookContext, examples: list[Case]) -> None:
     if not examples and context.operation is not None:
-        from ..._hypothesis import add_single_example
+        from ...generation import add_single_example
 
         strategy = context.operation.as_strategy()
         add_single_example(strategy, examples)

schemathesis/contrib/openapi/formats/uuid.py

@@ -3,9 +3,10 @@ FORMAT_NAME = "uuid"
 
 
 def install() -> None:
-    from ....specs import openapi
     from hypothesis import strategies as st
 
+    from ....specs import openapi
+
     openapi.format(FORMAT_NAME, st.uuids().map(str))
 
 

schemathesis/contrib/unique_data.py

@@ -6,14 +6,14 @@ from typing import TYPE_CHECKING
 from ..hooks import HookContext, register, unregister
 
 if TYPE_CHECKING:
-    from ..models import Case
     from hypothesis import strategies as st
 
+    from ..models import Case
+
 
 def install() -> None:
     warnings.warn(
-        "The `--contrib-unique-data` CLI option and the corresponding `schemathesis.contrib.unique_data` hook "
-        "are **DEPRECATED**. The concept of this feature does not fit the core principles of Hypothesis where "
+        "The `schemathesis.contrib.unique_data` hook is **DEPRECATED**. The concept of this feature does not fit the core principles of Hypothesis where "
         "strategies are configurable on a per-example basis but this feature implies uniqueness across examples. "
         "This leads to cryptic error messages about external state and flaky test runs, "
         "therefore it will be removed in Schemathesis 4.0",

schemathesis/exceptions.py

@@ -1,24 +1,28 @@
 from __future__ import annotations
+
 import enum
-import json
 import re
 import traceback
 from dataclasses import dataclass, field
 from hashlib import sha1
-from json import JSONDecodeError
-from types import TracebackType
 from typing import TYPE_CHECKING, Any, Callable, Generator, NoReturn
 
 from .constants import SERIALIZERS_SUGGESTION_MESSAGE
-from .failures import FailureContext
+from .internal.output import truncate_json
 
 if TYPE_CHECKING:
+    from json import JSONDecodeError
+    from types import TracebackType
+
     import hypothesis.errors
-    from jsonschema import RefResolutionError, ValidationError, SchemaError as JsonSchemaError
-    from .transports.responses import GenericResponse
     from graphql.error import GraphQLFormattedError
+    from jsonschema import RefResolutionError, ValidationError
+    from jsonschema import SchemaError as JsonSchemaError
     from requests import RequestException
 
+    from .failures import FailureContext
+    from .transports.responses import GenericResponse
+
 
 class CheckFailed(AssertionError):
     """Custom error type to distinguish from arbitrary AssertionError that may happen in the dependent libraries."""
@@ -97,52 +101,72 @@ def get_grouped_exception(prefix: str, *exceptions: AssertionError) -> type[Chec
     return _get_hashed_exception("GroupedException", f"{prefix}{message}")
 
 
-def get_server_error(status_code: int) -> type[CheckFailed]:
+def get_server_error(prefix: str, status_code: int) -> type[CheckFailed]:
     """Return new exception for the Internal Server Error cases."""
-    name = f"ServerError{status_code}"
+    name = f"ServerError{prefix}{status_code}"
     return get_exception(name)
 
 
-def get_status_code_error(status_code: int) -> type[CheckFailed]:
+def get_status_code_error(prefix: str, status_code: int) -> type[CheckFailed]:
     """Return new exception for an unexpected status code."""
-    name = f"StatusCodeError{status_code}"
+    name = f"StatusCodeError{prefix}{status_code}"
     return get_exception(name)
 
 
-def get_response_type_error(expected: str, received: str) -> type[CheckFailed]:
+def get_response_type_error(prefix: str, expected: str, received: str) -> type[CheckFailed]:
     """Return new exception for an unexpected response type."""
-    name = f"SchemaValidationError{expected}_{received}"
+    name = f"SchemaValidationError{prefix}{expected}_{received}"
     return get_exception(name)
 
 
-def get_malformed_media_type_error(media_type: str) -> type[CheckFailed]:
-    name = f"MalformedMediaType{media_type}"
+def get_malformed_media_type_error(prefix: str, media_type: str) -> type[CheckFailed]:
+    name = f"MalformedMediaType{prefix}{media_type}"
     return get_exception(name)
 
 
-def get_missing_content_type_error() -> type[CheckFailed]:
+def get_missing_content_type_error(prefix: str) -> type[CheckFailed]:
     """Return new exception for a missing Content-Type header."""
-    return get_exception("MissingContentTypeError")
+    return get_exception(f"MissingContentTypeError{prefix}")
 
 
-def get_schema_validation_error(exception: ValidationError) -> type[CheckFailed]:
+def get_schema_validation_error(prefix: str, exception: ValidationError) -> type[CheckFailed]:
     """Return new exception for schema validation error."""
-    return _get_hashed_exception("SchemaValidationError", str(exception))
+    return _get_hashed_exception(f"SchemaValidationError{prefix}", str(exception))
 
 
-def get_response_parsing_error(exception: JSONDecodeError) -> type[CheckFailed]:
+def get_response_parsing_error(prefix: str, exception: JSONDecodeError) -> type[CheckFailed]:
     """Return new exception for response parsing error."""
-    return _get_hashed_exception("ResponseParsingError", str(exception))
+    return _get_hashed_exception(f"ResponseParsingError{prefix}", str(exception))
 
 
-def get_headers_error(message: str) -> type[CheckFailed]:
+def get_headers_error(prefix: str, message: str) -> type[CheckFailed]:
     """Return new exception for missing headers."""
-    return _get_hashed_exception("MissingHeadersError", message)
+    return _get_hashed_exception(f"MissingHeadersError{prefix}", message)
+
+
+def get_negative_rejection_error(prefix: str, status: int) -> type[CheckFailed]:
+    return _get_hashed_exception(f"AcceptedNegativeDataError{prefix}", str(status))
+
 
+def get_positive_acceptance_error(prefix: str, status: int) -> type[CheckFailed]:
+    return _get_hashed_exception(f"RejectedPositiveDataError{prefix}", str(status))
 
-def get_timeout_error(deadline: float | int) -> type[CheckFailed]:
+
+def get_use_after_free_error(free: str) -> type[CheckFailed]:
+    return _get_hashed_exception("UseAfterFreeError", free)
+
+
+def get_ensure_resource_availability_error(operation: str) -> type[CheckFailed]:
+    return _get_hashed_exception("EnsureResourceAvailabilityError", operation)
+
+
+def get_ignored_auth_error(operation: str) -> type[CheckFailed]:
+    return _get_hashed_exception("IgnoredAuthError", operation)
+
+
+def get_timeout_error(prefix: str, deadline: float | int) -> type[CheckFailed]:
     """Request took too long."""
-    return _get_hashed_exception("TimeoutError", str(deadline))
+    return _get_hashed_exception(f"TimeoutError{prefix}", str(deadline))
 
 
 def get_unexpected_graphql_response_error(type_: type) -> type[CheckFailed]:
@@ -158,7 +182,7 @@ def get_grouped_graphql_error(errors: list[GraphQLFormattedError]) -> type[Check
         if "locations" in error:
             message += ";locations:"
             for location in sorted(error["locations"]):
-                message += f"({location['line'],location['column']})"
+                message += f"({location['line'], location['column']})"
         if "path" in error:
             message += ";path:"
             for chunk in error["path"]:
@@ -196,7 +220,7 @@ class OperationSchemaError(Exception):
             message = "Invalid schema definition"
         error_path = " -> ".join(str(entry) for entry in error.path) or "[root]"
         message += f"\n\nLocation:\n    {error_path}"
-        instance = truncated_json(error.instance)
+        instance = truncate_json(error.instance)
         message += f"\n\nProblematic definition:\n{instance}"
         message += "\n\nError details:\n    "
         # This default message contains the instance which we already printed
@@ -211,9 +235,11 @@ class OperationSchemaError(Exception):
     def from_reference_resolution_error(
         cls, error: RefResolutionError, path: str | None, method: str | None, full_path: str | None
     ) -> OperationSchemaError:
+        notes = getattr(error, "__notes__", [])
+        # Some exceptions don't have the actual reference in them, hence we add it manually via notes
+        pointer = f"'{notes[0]}'"
         message = "Unresolvable JSON pointer in the schema"
         # Get the pointer value from "Unresolvable JSON pointer: 'components/UnknownParameter'"
-        pointer = str(error).split(": ", 1)[-1]
         message += f"\n\nError details:\n    JSON pointer: {pointer}"
         message += "\n    This typically means that the schema is referencing a component that doesn't exist."
         message += f"\n\n{SCHEMA_ERROR_SUGGESTION}"
@@ -289,39 +315,6 @@ class InvalidHeadersExample(OperationSchemaError):
         return cls(message)
 
 
-def truncated_json(data: Any, max_lines: int = 10, max_width: int = 80) -> str:
-    # Convert JSON to string with indentation
-    indent = 4
-    serialized = json.dumps(data, indent=indent)
-
-    # Split string by lines
-
-    lines = [line[: max_width - 3] + "..." if len(line) > max_width else line for line in serialized.split("\n")]
-
-    if len(lines) <= max_lines:
-        return "\n".join(lines)
-
-    truncated_lines = lines[: max_lines - 1]
-    indentation = " " * indent
-    truncated_lines.append(f"{indentation}// Output truncated...")
-    truncated_lines.append(lines[-1])
-
-    return "\n".join(truncated_lines)
-
-
-MAX_PAYLOAD_SIZE = 512
-
-
-def prepare_response_payload(payload: str, max_size: int = MAX_PAYLOAD_SIZE) -> str:
-    if payload.endswith("\r\n"):
-        payload = payload[:-2]
-    elif payload.endswith("\n"):
-        payload = payload[:-1]
-    if len(payload) > max_size:
-        payload = payload[:max_size] + " // Output truncated..."
-    return payload
-
-
 class DeadlineExceeded(Exception):
     """Test took too long to run."""
 
@@ -336,6 +329,12 @@ class DeadlineExceeded(Exception):
         )
 
 
+class RecursiveReferenceError(Exception):
+    """Recursive reference is impossible to resolve due to current limitations."""
+
+    __module__ = "builtins"
+
+
 @enum.unique
 class RuntimeErrorType(str, enum.Enum):
     # Connection related issues
@@ -354,6 +353,7 @@ class RuntimeErrorType(str, enum.Enum):
 
     SCHEMA_BODY_IN_GET_REQUEST = "schema_body_in_get_request"
     SCHEMA_INVALID_REGULAR_EXPRESSION = "schema_invalid_regular_expression"
+    SCHEMA_UNSUPPORTED = "schema_unsupported"
     SCHEMA_GENERIC = "schema_generic"
 
     SERIALIZATION_NOT_POSSIBLE = "serialization_not_possible"
@@ -367,6 +367,7 @@ class RuntimeErrorType(str, enum.Enum):
         return self not in (
             RuntimeErrorType.SCHEMA_BODY_IN_GET_REQUEST,
             RuntimeErrorType.SCHEMA_INVALID_REGULAR_EXPRESSION,
+            RuntimeErrorType.SCHEMA_UNSUPPORTED,
             RuntimeErrorType.SCHEMA_GENERIC,
             RuntimeErrorType.SERIALIZATION_NOT_POSSIBLE,
         )
@@ -532,8 +533,14 @@ def remove_ssl_line_number(text: str) -> str:
     return re.sub(r"\(_ssl\.c:\d+\)", "", text)
 
 
+def _clean_inner_request_message(message: Any) -> str:
+    if isinstance(message, str) and message.startswith("HTTPConnectionPool"):
+        return re.sub(r"HTTPConnectionPool\(.+?\): ", "", message).rstrip(".")
+    return str(message)
+
+
 def extract_requests_exception_details(exc: RequestException) -> tuple[str, list[str]]:
-    from requests.exceptions import SSLError, ConnectionError, ChunkedEncodingError
+    from requests.exceptions import ChunkedEncodingError, ConnectionError, SSLError
     from urllib3.exceptions import MaxRetryError
 
     if isinstance(exc, SSLError):
@@ -544,13 +551,17 @@ def extract_requests_exception_details(exc: RequestException) -> tuple[str, list
         message = "Connection failed"
         inner = exc.args[0]
         if isinstance(inner, MaxRetryError) and inner.reason is not None:
-            if ":" not in inner.reason.args[0]:
-                reason = inner.reason.args[0]
+            arg = inner.reason.args[0]
+            if isinstance(arg, str):
+                if ":" not in arg:
+                    reason = arg
+                else:
+                    _, reason = arg.split(":", maxsplit=1)
             else:
-                _, reason = inner.reason.args[0].split(":", maxsplit=1)
+                reason = f"Max retries exceeded with url: {inner.url}"
             extra = [reason.strip()]
         else:
-            extra = [" ".join(map(str, inner.args))]
+            extra = [" ".join(map(_clean_inner_request_message, inner.args))]
     elif isinstance(exc, ChunkedEncodingError):
         message = "Connection broken. The server declared chunked encoding but sent an invalid chunk"
         extra = [str(exc.args[0].args[1])]

schemathesis/experimental/__init__.py

@@ -72,3 +72,38 @@ OPEN_API_3_1 = GLOBAL_EXPERIMENTS.create_experiment(
     description="Support for response validation",
     discussion_url="https://github.com/schemathesis/schemathesis/discussions/1822",
 )
+SCHEMA_ANALYSIS = GLOBAL_EXPERIMENTS.create_experiment(
+    name="schema-analysis",
+    verbose_name="Schema Analysis",
+    env_var="SCHEMA_ANALYSIS",
+    description="Analyzing API schemas via Schemathesis.io",
+    discussion_url="https://github.com/schemathesis/schemathesis/discussions/2056",
+)
+STATEFUL_TEST_RUNNER = GLOBAL_EXPERIMENTS.create_experiment(
+    name="stateful-test-runner",
+    verbose_name="New Stateful Test Runner",
+    env_var="STATEFUL_TEST_RUNNER",
+    description="State machine-based runner for stateful tests in CLI",
+    discussion_url="https://github.com/schemathesis/schemathesis/discussions/2262",
+)
+STATEFUL_ONLY = GLOBAL_EXPERIMENTS.create_experiment(
+    name="stateful-only",
+    verbose_name="Stateful Only",
+    env_var="STATEFUL_ONLY",
+    description="Run only stateful tests",
+    discussion_url="https://github.com/schemathesis/schemathesis/discussions/2262",
+)
+COVERAGE_PHASE = GLOBAL_EXPERIMENTS.create_experiment(
+    name="coverage-phase",
+    verbose_name="Coverage phase",
+    env_var="COVERAGE_PHASE",
+    description="Generate covering test cases",
+    discussion_url="https://github.com/schemathesis/schemathesis/discussions/2418",
+)
+POSITIVE_DATA_ACCEPTANCE = GLOBAL_EXPERIMENTS.create_experiment(
+    name="positive_data_acceptance",
+    verbose_name="Positive Data Acceptance",
+    env_var="POSITIVE_DATA_ACCEPTANCE",
+    description="Verifying schema-conformant data is accepted",
+    discussion_url="https://github.com/schemathesis/schemathesis/discussions/2499",
+)

schemathesis/extra/_aiohttp.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 import asyncio
 
 from aiohttp import web

schemathesis/extra/_flask.py

@@ -1,9 +1,12 @@
 from __future__ import annotations
 
-from flask import Flask
+from typing import TYPE_CHECKING
 
 from . import _server
 
+if TYPE_CHECKING:
+    from flask import Flask
+
 
 def run_server(app: Flask, port: int | None = None, timeout: float = 0.05) -> int:
     """Start a thread with the given aiohttp application."""

schemathesis/extra/_server.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 import threading
 from time import sleep
 from typing import Any, Callable

schemathesis/extra/pytest_plugin.py

@@ -3,19 +3,17 @@ from __future__ import annotations
 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.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 .._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,
@@ -31,7 +29,6 @@ from ..exceptions import (
     UsageError,
 )
 from ..internal.result import Ok, Result
-from ..models import APIOperation
 from ..utils import (
     PARAMETRIZE_MARKER,
     fail_on_no_matches,
@@ -43,13 +40,10 @@ from ..utils import (
     validate_given_args,
 )
 
-T = TypeVar("T", bound=Node)
+if TYPE_CHECKING:
+    from _pytest.fixtures import FuncFixtureInfo
 
-
-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)
+    from ..models import APIOperation
 
 
 class SchemathesisFunction(Function):
@@ -155,7 +149,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 +162,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,
@@ -181,10 +176,9 @@ class SchemathesisCase(PyCollector):
             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,
@@ -206,7 +200,7 @@ class SchemathesisCase(PyCollector):
             kwargs["_ispytest"] = True
         metafunc = Metafunc(definition, fixtureinfo, self.config, **kwargs)
         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)
@@ -236,7 +230,7 @@ def pytest_pycollect_makeitem(collector: nodes.Collector, name: str, obj: Any) -
     """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))
+        outcome.force_result(SchemathesisCase.from_parent(collector, test_function=obj, name=name))
     else:
         outcome.get_result()
 
@@ -261,7 +255,7 @@ def skip_unnecessary_hypothesis_output() -> Generator:
         yield
 
 
-@hookimpl(hookwrapper=True)
+@hookimpl(wrapper=True)
 def pytest_pyfunc_call(pyfuncitem):  # type:ignore
     """It is possible to have a Hypothesis exception in runtime.
 
@@ -278,10 +272,9 @@ def pytest_pyfunc_call(pyfuncitem):  # type:ignore
 
     __tracebackhide__ = True
     if isinstance(pyfuncitem, SchemathesisFunction):
-        with skip_unnecessary_hypothesis_output():
-            outcome = yield
         try:
-            outcome.get_result()
+            with skip_unnecessary_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
@@ -316,5 +309,4 @@ def pytest_pyfunc_call(pyfuncitem):  # type:ignore
         if invalid_headers is not None:
             raise InvalidHeadersExample.from_headers(invalid_headers) from None
     else:
-        outcome = yield
-        outcome.get_result()
+        yield