schemathesis 3.19.7__py3-none-any.whl → 3.20.1__py3-none-any.whl

schemathesis/models.py

@@ -1,10 +1,12 @@
 import base64
 import datetime
 import http
+import inspect
 from collections import Counter
 from contextlib import contextmanager
 from dataclasses import dataclass, field
 from enum import Enum
+from functools import partial
 from itertools import chain
 from logging import LogRecord
 from typing import (
@@ -26,9 +28,7 @@ from typing import (
     cast,
 )
 from urllib.parse import quote, unquote, urljoin, urlparse, urlsplit, urlunsplit
-from uuid import uuid4
 
-import curlify
 import requests.auth
 import werkzeug
 from hypothesis import event, note, reject
@@ -37,19 +37,20 @@ from requests.structures import CaseInsensitiveDict
 from starlette_testclient import TestClient as ASGIClient
 
 from . import failures, serializers
+from ._compat import IS_WERKZEUG_ABOVE_3
 from .auths import AuthStorage
+from .code_samples import CodeSampleStyle
 from .constants import (
     DEFAULT_RESPONSE_TIMEOUT,
     SCHEMATHESIS_TEST_CASE_HEADER,
     SERIALIZERS_SUGGESTION_MESSAGE,
     USER_AGENT,
-    CodeSampleStyle,
     DataGenerationMethod,
 )
 from .exceptions import (
     CheckFailed,
     FailureContext,
-    InvalidSchema,
+    OperationSchemaError,
     SerializationNotPossible,
     deduplicate_failed_checks,
     get_grouped_exception,
@@ -57,16 +58,17 @@ from .exceptions import (
 )
 from .hooks import GLOBAL_HOOK_DISPATCHER, HookContext, HookDispatcher, dispatch
 from .parameters import Parameter, ParameterSet, PayloadAlternatives
+from .sanitization import sanitize_request, sanitize_response
 from .serializers import Serializer, SerializerContext
 from .types import Body, Cookies, FormData, Headers, NotSet, PathParameters, Query
 from .utils import (
-    IGNORED_HEADERS,
     NOT_SET,
     GenericResponse,
     WSGIResponse,
     copy_response,
     deprecated_property,
     fast_deepcopy,
+    generate_random_case_id,
     get_response_payload,
     maybe_set_assertion_message,
 )
@@ -98,11 +100,33 @@ def cant_serialize(media_type: str) -> NoReturn:  # type: ignore
     reject()  # type: ignore
 
 
+REQUEST_SIGNATURE = inspect.signature(requests.Request)
+
+
+@dataclass()
+class PreparedRequestData:
+    method: str
+    url: str
+    body: Optional[Union[str, bytes]]
+    headers: Headers
+
+
+def prepare_request_data(kwargs: Dict[str, Any]) -> PreparedRequestData:
+    """Prepare request data for generating code samples."""
+    kwargs = {key: value for key, value in kwargs.items() if key in REQUEST_SIGNATURE.parameters}
+    request = requests.Request(**kwargs).prepare()
+    return PreparedRequestData(
+        method=str(request.method), url=str(request.url), body=request.body, headers=dict(request.headers)
+    )
+
+
 @dataclass(repr=False)
 class Case:
     """A single test case parameters."""
 
     operation: "APIOperation"
+    # Unique test case identifier
+    id: str = field(default_factory=generate_random_case_id, compare=False)
     path_parameters: Optional[PathParameters] = None
     headers: Optional[CaseInsensitiveDict] = None
     cookies: Optional[Cookies] = None
@@ -110,14 +134,12 @@ class Case:
     # By default, there is no body, but we can't use `None` as the default value because it clashes with `null`
     # which is a valid payload.
     body: Union[Body, NotSet] = NOT_SET
-
-    source: Optional[CaseSource] = None
     # The media type for cases with a payload. For example, "application/json"
     media_type: Optional[str] = None
+    source: Optional[CaseSource] = None
+
     # The way the case was generated (None for manually crafted ones)
     data_generation_method: Optional[DataGenerationMethod] = None
-    # Unique test case identifier
-    id: str = field(default_factory=lambda: uuid4().hex, compare=False)
     _auth: Optional[requests.auth.AuthBase] = None
 
     def __repr__(self) -> str:
@@ -171,10 +193,10 @@ class Case:
             # This may happen when a path template has a placeholder for variable "X", but parameter "X" is not defined
             # in the parameters list.
             # When `exc` is formatted, it is the missing key name in quotes. E.g. 'id'
-            raise InvalidSchema(f"Path parameter {exc} is not defined") from exc
+            raise OperationSchemaError(f"Path parameter {exc} is not defined") from exc
         except ValueError as exc:
             # A single unmatched `}` inside the path template may cause this
-            raise InvalidSchema(f"Malformed path template: `{self.path}`\n\n  {exc}") from exc
+            raise OperationSchemaError(f"Malformed path template: `{self.path}`\n\n  {exc}") from exc
 
     def get_full_base_url(self) -> Optional[str]:
         """Create a full base url, adding "localhost" for WSGI apps."""
@@ -184,59 +206,49 @@ class Case:
             return urlunsplit(("http", "localhost", path or "", "", ""))
         return self.base_url
 
+    def prepare_code_sample_data(self, headers: Optional[Dict[str, Any]]) -> PreparedRequestData:
+        base_url = self.get_full_base_url()
+        kwargs = self.as_requests_kwargs(base_url, headers=headers)
+        return prepare_request_data(kwargs)
+
     def get_code_to_reproduce(
-        self, headers: Optional[Dict[str, Any]] = None, request: Optional[requests.PreparedRequest] = None
+        self,
+        headers: Optional[Dict[str, Any]] = None,
+        request: Optional[requests.PreparedRequest] = None,
+        verify: bool = True,
     ) -> str:
         """Construct a Python code to reproduce this case with `requests`."""
         if request is not None:
-            kwargs: Dict[str, Any] = {
-                "method": request.method,
-                "url": request.url,
-                "headers": request.headers,
-                "data": request.body,
-            }
+            request_data = prepare_request_data(
+                {
+                    "method": request.method,
+                    "url": request.url,
+                    "headers": request.headers,
+                    "data": request.body,
+                }
+            )
         else:
-            base_url = self.get_full_base_url()
-            kwargs = self.as_requests_kwargs(base_url)
-        if headers:
-            final_headers = kwargs["headers"] or {}
-            final_headers.update(headers)
-            kwargs["headers"] = final_headers
-        kwargs["headers"] = {key: value for key, value in kwargs["headers"].items() if key not in IGNORED_HEADERS}
-        method = kwargs["method"].lower()
-
-        def should_display(key: str, value: Any) -> bool:
-            if key in ("method", "url"):
-                return False
-            # Parameters are either absent because they are not defined or are optional
-            return value not in (None, {})
-
-        printed_kwargs = ", ".join(
-            f"{key}={repr(value)}" for key, value in kwargs.items() if should_display(key, value)
+            request_data = self.prepare_code_sample_data(headers)
+        return CodeSampleStyle.python.generate(
+            method=request_data.method,
+            url=request_data.url,
+            body=request_data.body,
+            headers=dict(self.headers) if self.headers is not None else None,
+            verify=verify,
+            extra_headers=request_data.headers,
         )
-        url = _escape_single_quotes(kwargs["url"])
-        args_repr = f"'{url}'"
-        if printed_kwargs:
-            args_repr += f", {printed_kwargs}"
-        return f"requests.{method}({args_repr})"
 
-    def as_curl_command(self, headers: Optional[Dict[str, Any]] = None) -> str:
+    def as_curl_command(self, headers: Optional[Dict[str, Any]] = None, verify: bool = True) -> str:
         """Construct a curl command for a given case."""
-        base_url = self.get_full_base_url()
-        kwargs = self.as_requests_kwargs(base_url)
-        if headers:
-            final_headers = kwargs["headers"] or {}
-            final_headers.update(headers)
-            kwargs["headers"] = final_headers
-        request = requests.Request(**kwargs)
-        prepared = request.prepare()
-        if isinstance(prepared.body, bytes):
-            # Note, it may be not sufficient to reproduce the error :(
-            prepared.body = prepared.body.decode("utf-8", errors="replace")
-        for header in tuple(prepared.headers):
-            if header in IGNORED_HEADERS and header not in (self.headers or {}):
-                del prepared.headers[header]
-        return curlify.to_curl(prepared)
+        request_data = self.prepare_code_sample_data(headers)
+        return CodeSampleStyle.curl.generate(
+            method=request_data.method,
+            url=request_data.url,
+            body=request_data.body,
+            headers=dict(self.headers) if self.headers is not None else None,
+            verify=verify,
+            extra_headers=request_data.headers,
+        )
 
     def _get_base_url(self, base_url: Optional[str] = None) -> str:
         if base_url is None:
@@ -332,16 +344,19 @@ class Case:
             close_session = True
         else:
             close_session = False
+        verify = data.get("verify", True)
         try:
             with self.operation.schema.ratelimit():
                 response = session.request(**data)  # type: ignore
         except requests.Timeout as exc:
             timeout = 1000 * data["timeout"]  # It is defined and not empty, since the exception happened
-            code_message = self._get_code_message(self.operation.schema.code_sample_style, exc.request)
+            request = cast(requests.PreparedRequest, exc.request)
+            code_message = self._get_code_message(self.operation.schema.code_sample_style, request, verify=verify)
             raise get_timeout_error(timeout)(
                 f"\n\n1. Request timed out after {timeout:.2f}ms\n\n----------\n\n{code_message}",
                 context=failures.RequestTimeout(timeout=timeout),
             ) from None
+        response.verify = verify  # type: ignore[attr-defined]
         dispatch("after_call", hook_context, self, response)
         if close_session:
             session.close()
@@ -410,9 +425,9 @@ class Case:
             )
         if base_url is None:
             base_url = self.get_full_base_url()
-        client = ASGIClient(application)
 
-        return self.call(base_url=base_url, session=client, headers=headers, **kwargs)
+        with ASGIClient(application) as client:
+            return self.call(base_url=base_url, session=client, headers=headers, **kwargs)
 
     def validate_response(
         self,
@@ -430,6 +445,7 @@ class Case:
         :param checks: A tuple of check functions that accept ``response`` and ``case``.
         :param additional_checks: A tuple of additional checks that will be executed after ones from the ``checks``
             argument.
+        :param excluded_checks: Checks excluded from the default ones.
         :param code_sample_style: Controls the style of code samples for failure reproduction.
         """
         __tracebackhide__ = True
@@ -456,7 +472,11 @@ class Case:
                 if code_sample_style is not None
                 else self.operation.schema.code_sample_style
             )
-            code_message = self._get_code_message(code_sample_style, response.request)
+            verify = getattr(response, "verify", True)
+            if self.operation.schema.sanitize_output:
+                sanitize_request(response.request)
+                sanitize_response(response)
+            code_message = self._get_code_message(code_sample_style, response.request, verify=verify)
             payload = get_response_payload(response)
             raise exception_cls(
                 f"\n\n{formatted_failures}\n\n"
@@ -467,12 +487,14 @@ class Case:
                 causes=tuple(failed_checks),
             )
 
-    def _get_code_message(self, code_sample_style: CodeSampleStyle, request: requests.PreparedRequest) -> str:
+    def _get_code_message(
+        self, code_sample_style: CodeSampleStyle, request: requests.PreparedRequest, verify: bool
+    ) -> str:
         if code_sample_style == CodeSampleStyle.python:
-            code = self.get_code_to_reproduce(request=request)
+            code = self.get_code_to_reproduce(request=request, verify=verify)
             return f"Run this Python code to reproduce this response: \n\n    {code}\n"
         if code_sample_style == CodeSampleStyle.curl:
-            code = self.as_curl_command(headers=dict(request.headers))
+            code = self.as_curl_command(headers=dict(request.headers), verify=verify)
             return f"Run this cURL command to reproduce this response: \n\n    {code}\n"
         raise ValueError(f"Unknown code sample style: {code_sample_style.name}")
 
@@ -492,7 +514,7 @@ class Case:
 
     def get_full_url(self) -> str:
         """Make a full URL to the current API operation, including query parameters."""
-        base_url = self.base_url or "http://localhost"
+        base_url = self.base_url or "http://127.0.0.1"
         kwargs = self.as_requests_kwargs(base_url)
         request = requests.Request(**kwargs)
         prepared = requests.Session().prepare_request(request)  # type: ignore
@@ -534,27 +556,6 @@ def validate_vanilla_requests_kwargs(data: Dict[str, Any]) -> None:
         )
 
 
-def _escape_single_quotes(url: str) -> str:
-    """Escape single quotes in a string, so it is usable as in generated Python code.
-
-    The usual ``str.replace`` is not suitable as it may convert already escaped quotes to not-escaped.
-    """
-    result = []
-    escape = False
-    for char in url:
-        if escape:
-            result.append(char)
-            escape = False
-        elif char == "\\":
-            result.append(char)
-            escape = True
-        elif char == "'":
-            result.append("\\'")
-        else:
-            result.append(char)
-    return "".join(result)
-
-
 @contextmanager
 def cookie_handler(client: werkzeug.Client, cookies: Optional[Cookies]) -> Generator[None, None, None]:
     """Set cookies required for a call."""
@@ -562,10 +563,16 @@ def cookie_handler(client: werkzeug.Client, cookies: Optional[Cookies]) -> Gener
         yield
     else:
         for key, value in cookies.items():
-            client.set_cookie("localhost", key, value)
+            if IS_WERKZEUG_ABOVE_3:
+                client.set_cookie(key=key, value=value, domain="localhost")
+            else:
+                client.set_cookie("localhost", key=key, value=value)
         yield
         for key in cookies:
-            client.delete_cookie("localhost", key)
+            if IS_WERKZEUG_ABOVE_3:
+                client.delete_cookie(key=key, domain="localhost")
+            else:
+                client.delete_cookie("localhost", key=key)
 
 
 P = TypeVar("P", bound=Parameter)
@@ -685,8 +692,18 @@ class APIOperation(Generic[P, C]):
         strategy = self.schema.get_case_strategy(self, hooks, auth_storage, data_generation_method, **kwargs)
 
         def _apply_hooks(dispatcher: HookDispatcher, _strategy: st.SearchStrategy[Case]) -> st.SearchStrategy[Case]:
+            context = HookContext(self)
             for hook in dispatcher.get_all_by_name("before_generate_case"):
-                _strategy = hook(HookContext(self), _strategy)
+                _strategy = hook(context, _strategy)
+            for hook in dispatcher.get_all_by_name("filter_case"):
+                hook = partial(hook, context)
+                _strategy = _strategy.filter(hook)
+            for hook in dispatcher.get_all_by_name("map_case"):
+                hook = partial(hook, context)
+                _strategy = _strategy.map(hook)
+            for hook in dispatcher.get_all_by_name("flatmap_case"):
+                hook = partial(hook, context)
+                _strategy = _strategy.flatmap(hook)
             return _strategy
 
         strategy = _apply_hooks(GLOBAL_HOOK_DISPATCHER, strategy)
@@ -797,6 +814,12 @@ class APIOperation(Generic[P, C]):
         except CheckFailed:
             return False
 
+    def get_raw_payload_schema(self, media_type: str) -> Optional[Dict[str, Any]]:
+        return self.schema._get_payload_schema(self.definition.raw, media_type)
+
+    def get_resolved_payload_schema(self, media_type: str) -> Optional[Dict[str, Any]]:
+        return self.schema._get_payload_schema(self.definition.resolved, media_type)
+
 
 # backward-compatibility
 Endpoint = APIOperation
@@ -879,6 +902,7 @@ class Response:
     encoding: Optional[str]
     http_version: str
     elapsed: float
+    verify: bool
 
     @classmethod
     def from_requests(cls, response: requests.Response) -> "Response":
@@ -902,6 +926,7 @@ class Response:
             headers=headers,
             http_version=http_version,
             elapsed=response.elapsed.total_seconds(),
+            verify=getattr(response, "verify", True),
         )
 
     @classmethod
@@ -914,7 +939,8 @@ class Response:
         body = None if response.response == [] else serialize_payload(data)
         encoding: Optional[str]
         if body is not None:
-            encoding = response.mimetype_params.get("charset", response.charset)
+            # Werkzeug <3.0 had `charset` attr, newer versions always have UTF-8
+            encoding = response.mimetype_params.get("charset", getattr(response, "charset", "utf-8"))
         else:
             encoding = None
         return cls(
@@ -925,6 +951,7 @@ class Response:
             headers=headers,
             http_version="1.1",
             elapsed=elapsed,
+            verify=True,
         )
 
 
@@ -983,7 +1010,7 @@ class TestResult:
     verbose_name: str
     data_generation_method: List[DataGenerationMethod]
     checks: List[Check] = field(default_factory=list)
-    errors: List[Tuple[Exception, Optional[Case]]] = field(default_factory=list)
+    errors: List[Exception] = field(default_factory=list)
     interactions: List[Interaction] = field(default_factory=list)
     logs: List[LogRecord] = field(default_factory=list)
     is_errored: bool = False
@@ -991,9 +1018,6 @@ class TestResult:
     is_skipped: bool = False
     is_executed: bool = False
     seed: Optional[int] = None
-    # To show a proper reproduction code if an error happens and there is no way to get actual headers that were
-    # sent over the network. Or there could be no actual requests at all
-    overridden_headers: Optional[Dict[str, Any]] = None
 
     def mark_errored(self) -> None:
         self.is_errored = True
@@ -1049,8 +1073,8 @@ class TestResult:
         self.checks.append(check)
         return check
 
-    def add_error(self, exception: Exception, example: Optional[Case] = None) -> None:
-        self.errors.append((exception, example))
+    def add_error(self, exception: Exception) -> None:
+        self.errors.append(exception)
 
     def store_requests_response(
         self, case: Case, response: requests.Response, status: Status, checks: List[Check]
@@ -1076,7 +1100,7 @@ class TestResultSet:
     __test__ = False
 
     results: List[TestResult] = field(default_factory=list)
-    generic_errors: List[InvalidSchema] = field(default_factory=list)
+    generic_errors: List[OperationSchemaError] = field(default_factory=list)
     warnings: List[str] = field(default_factory=list)
 
     def __iter__(self) -> Iterator[TestResult]:

schemathesis/parameters.py

@@ -67,6 +67,9 @@ class ParameterSet(Generic[P]):
                 return parameter
         return None
 
+    def contains(self, name: str) -> bool:
+        return self.get(name) is not None
+
     @property
     def example(self) -> Dict[str, Any]:
         """Composite example gathered from individual parameters."""

schemathesis/runner/__init__.py

@@ -13,6 +13,7 @@ from ..constants import (
     HYPOTHESIS_IN_MEMORY_DATABASE_IDENTIFIER,
     DataGenerationMethod,
 )
+from ..exceptions import SchemaError
 from ..models import CheckFunction
 from ..schemas import BaseSchema
 from ..specs.graphql import loaders as gql_loaders
@@ -236,6 +237,8 @@ def execute_from_schema(
             stateful_recursion_limit=stateful_recursion_limit,
             count_operations=count_operations,
         ).execute()
+    except SchemaError as error:
+        yield events.InternalError.from_schema_error(error)
     except Exception as exc:
         yield events.InternalError.from_exc(exc)
 

schemathesis/runner/events.py

@@ -1,12 +1,11 @@
+import enum
 import threading
 import time
 from dataclasses import asdict, dataclass, field
 from typing import Any, Dict, List, Optional, Union
 
-from requests import exceptions
-
-from ..constants import USE_WAIT_FOR_SCHEMA_SUGGESTION_MESSAGE, DataGenerationMethod
-from ..exceptions import HTTPError
+from ..constants import DataGenerationMethod
+from ..exceptions import SchemaError, SchemaErrorType
 from ..models import APIOperation, Status, TestResult, TestResultSet
 from ..schemas import BaseSchema
 from ..utils import current_datetime, format_exception
@@ -168,37 +167,73 @@ class Interrupted(ExecutionEvent):
     thread_id: int = field(default_factory=threading.get_ident)
 
 
+@enum.unique
+class InternalErrorType(str, enum.Enum):
+    SCHEMA = "schema"
+    OTHER = "other"
+
+
 @dataclass
 class InternalError(ExecutionEvent):
     """An error that happened inside the runner."""
 
     is_terminal = True
 
+    # Main error info
+    type: InternalErrorType
+    subtype: Optional[SchemaErrorType]
+    title: str
     message: str
+    extras: List[str]
+
+    # Exception info
     exception_type: str
-    exception: Optional[str] = None
-    exception_with_traceback: Optional[str] = None
+    exception: str
+    exception_with_traceback: str
+    # Auxiliary data
     thread_id: int = field(default_factory=threading.get_ident)
 
     @classmethod
-    def from_exc(cls, exc: Exception, wait_for_schema: Optional[float] = None) -> "InternalError":
+    def from_schema_error(cls, error: SchemaError) -> "InternalError":
+        return cls.with_exception(
+            error,
+            type_=InternalErrorType.SCHEMA,
+            subtype=error.type,
+            title="Schema Loading Error",
+            message=error.message,
+            extra=error.extras,
+        )
+
+    @classmethod
+    def from_exc(cls, exc: Exception) -> "InternalError":
+        return cls.with_exception(
+            exc,
+            type_=InternalErrorType.OTHER,
+            subtype=None,
+            title="Test Execution Error",
+            message="An internal error occurred during the test run",
+            extra=[],
+        )
+
+    @classmethod
+    def with_exception(
+        cls,
+        exc: Exception,
+        type_: InternalErrorType,
+        subtype: Optional[SchemaErrorType],
+        title: str,
+        message: str,
+        extra: List[str],
+    ) -> "InternalError":
         exception_type = f"{exc.__class__.__module__}.{exc.__class__.__qualname__}"
-        if isinstance(exc, HTTPError):
-            if exc.response.status_code == 404:
-                message = f"Schema was not found at {exc.url}"
-            else:
-                message = f"Failed to load schema, code {exc.response.status_code} was returned from {exc.url}"
-            return cls(message=message, exception_type=exception_type)
         exception = format_exception(exc)
         exception_with_traceback = format_exception(exc, include_traceback=True)
-        if isinstance(exc, exceptions.ConnectionError):
-            message = f"Failed to load schema from {exc.request.url}"
-            if wait_for_schema is None:
-                message += f"\n{USE_WAIT_FOR_SCHEMA_SUGGESTION_MESSAGE}"
-        else:
-            message = "An internal error happened during a test run"
         return cls(
+            type=type_,
+            subtype=subtype,
+            title=title,
             message=message,
+            extras=extra,
             exception_type=exception_type,
             exception=exception,
             exception_with_traceback=exception_with_traceback,
@@ -245,7 +280,7 @@ class Finished(ExecutionEvent):
             is_empty=results.is_empty,
             total=results.total,
             generic_errors=[
-                SerializedError.from_error(error, None, None, error.full_path) for error in results.generic_errors
+                SerializedError.from_error(exception=error, title=error.full_path) for error in results.generic_errors
             ],
             warnings=results.warnings,
             running_time=running_time,