schemathesis 4.0.0a11__py3-none-any.whl → 4.0.0b1__py3-none-any.whl

schemathesis/config/_phases.py

@@ -39,24 +39,59 @@ class PhaseConfig(DiffBase):
         )
 
 
+@dataclass(repr=False)
+class ExamplesPhaseConfig(DiffBase):
+    enabled: bool
+    fill_missing: bool
+    generation: GenerationConfig
+    checks: ChecksConfig
+
+    __slots__ = ("enabled", "fill_missing", "generation", "checks")
+
+    def __init__(
+        self,
+        *,
+        enabled: bool = True,
+        fill_missing: bool = False,
+        generation: GenerationConfig | None = None,
+        checks: ChecksConfig | None = None,
+    ) -> None:
+        self.enabled = enabled
+        self.fill_missing = fill_missing
+        self.generation = generation or GenerationConfig()
+        self.checks = checks or ChecksConfig()
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> ExamplesPhaseConfig:
+        return cls(
+            enabled=data.get("enabled", True),
+            fill_missing=data.get("fill-missing", False),
+            generation=GenerationConfig.from_dict(data.get("generation", {})),
+            checks=ChecksConfig.from_dict(data.get("checks", {})),
+        )
+
+
 @dataclass(repr=False)
 class CoveragePhaseConfig(DiffBase):
     enabled: bool
+    generate_duplicate_query_parameters: bool
     generation: GenerationConfig
     checks: ChecksConfig
     unexpected_methods: set[str]
 
-    __slots__ = ("enabled", "generation", "checks", "unexpected_methods")
+    __slots__ = ("enabled", "generate_duplicate_query_parameters", "generation", "checks", "unexpected_methods")
 
     def __init__(
         self,
         *,
         enabled: bool = True,
+        generate_duplicate_query_parameters: bool = False,
         generation: GenerationConfig | None = None,
         checks: ChecksConfig | None = None,
         unexpected_methods: set[str] | None = None,
     ) -> None:
         self.enabled = enabled
+        self.generate_duplicate_query_parameters = generate_duplicate_query_parameters
         self.unexpected_methods = unexpected_methods or DEFAULT_UNEXPECTED_METHODS
         self.generation = generation or GenerationConfig()
         self.checks = checks or ChecksConfig()
@@ -65,6 +100,7 @@ class CoveragePhaseConfig(DiffBase):
     def from_dict(cls, data: dict[str, Any]) -> CoveragePhaseConfig:
         return cls(
             enabled=data.get("enabled", True),
+            generate_duplicate_query_parameters=data.get("generate-duplicate-query-parameters", False),
             unexpected_methods={method.lower() for method in data.get("unexpected-methods", [])}
             if "unexpected-methods" in data
             else None,
@@ -107,7 +143,7 @@ class StatefulPhaseConfig(DiffBase):
 
 @dataclass(repr=False)
 class PhasesConfig(DiffBase):
-    examples: PhaseConfig
+    examples: ExamplesPhaseConfig
     coverage: CoveragePhaseConfig
     fuzzing: PhaseConfig
     stateful: StatefulPhaseConfig
@@ -117,12 +153,12 @@ class PhasesConfig(DiffBase):
     def __init__(
         self,
         *,
-        examples: PhaseConfig | None = None,
+        examples: ExamplesPhaseConfig | None = None,
         coverage: CoveragePhaseConfig | None = None,
         fuzzing: PhaseConfig | None = None,
         stateful: StatefulPhaseConfig | None = None,
     ) -> None:
-        self.examples = examples or PhaseConfig()
+        self.examples = examples or ExamplesPhaseConfig()
         self.coverage = coverage or CoveragePhaseConfig()
         self.fuzzing = fuzzing or PhaseConfig()
         self.stateful = stateful or StatefulPhaseConfig()
@@ -138,7 +174,7 @@ class PhasesConfig(DiffBase):
     @classmethod
     def from_dict(cls, data: dict[str, Any]) -> PhasesConfig:
         return cls(
-            examples=PhaseConfig.from_dict(data.get("examples", {})),
+            examples=ExamplesPhaseConfig.from_dict(data.get("examples", {})),
             coverage=CoveragePhaseConfig.from_dict(data.get("coverage", {})),
             fuzzing=PhaseConfig.from_dict(data.get("fuzzing", {})),
             stateful=StatefulPhaseConfig.from_dict(data.get("stateful", {})),

schemathesis/config/_projects.py

@@ -17,6 +17,7 @@ from schemathesis.config._parameters import load_parameters
 from schemathesis.config._phases import PhasesConfig
 from schemathesis.config._rate_limit import build_limiter
 from schemathesis.config._report import ReportsConfig
+from schemathesis.config._warnings import SchemathesisWarning, resolve_warnings
 from schemathesis.core import HYPOTHESIS_IN_MEMORY_DATABASE_IDENTIFIER, hooks
 from schemathesis.core.validation import validate_base_url
 
@@ -57,6 +58,7 @@ class ProjectConfig(DiffBase):
     request_cert: str | None
     request_cert_key: str | None
     parameters: dict[str, Any]
+    warnings: list[SchemathesisWarning] | None
     auth: AuthConfig
     checks: ChecksConfig
     phases: PhasesConfig
@@ -78,6 +80,7 @@ class ProjectConfig(DiffBase):
         "request_cert",
         "request_cert_key",
         "parameters",
+        "warnings",
         "auth",
         "checks",
         "phases",
@@ -101,6 +104,7 @@ class ProjectConfig(DiffBase):
         request_cert: str | None = None,
         request_cert_key: str | None = None,
         parameters: dict[str, Any] | None = None,
+        warnings: bool | list[SchemathesisWarning] | None = None,
         auth: AuthConfig | None = None,
         checks: ChecksConfig | None = None,
         phases: PhasesConfig | None = None,
@@ -133,6 +137,7 @@ class ProjectConfig(DiffBase):
         self.request_cert = request_cert
         self.request_cert_key = request_cert_key
         self.parameters = parameters or {}
+        self._set_warnings(warnings)
         self.auth = auth or AuthConfig()
         self.checks = checks or ChecksConfig()
         self.phases = phases or PhasesConfig()
@@ -157,6 +162,7 @@ class ProjectConfig(DiffBase):
             request_cert_key=resolve(data.get("request-cert-key")),
             parameters=load_parameters(data),
             auth=AuthConfig.from_dict(data.get("auth", {})),
+            warnings=resolve_warnings(data.get("warnings")),
             checks=ChecksConfig.from_dict(data.get("checks", {})),
             phases=PhasesConfig.from_dict(data.get("phases", {})),
             generation=GenerationConfig.from_dict(data.get("generation", {})),
@@ -165,6 +171,14 @@ class ProjectConfig(DiffBase):
             ),
         )
 
+    def _set_warnings(self, warnings: bool | list[SchemathesisWarning] | None) -> None:
+        if warnings is False:
+            self.warnings = []
+        elif warnings is True:
+            self.warnings = list(SchemathesisWarning)
+        else:
+            self.warnings = warnings
+
     def update(
         self,
         *,
@@ -178,8 +192,10 @@ class ProjectConfig(DiffBase):
         tls_verify: bool | str | None = None,
         request_cert: str | None = None,
         request_cert_key: str | None = None,
+        parameters: dict[str, Any] | None = None,
         proxy: str | None = None,
         suppress_health_check: list[HealthCheck] | None = None,
+        warnings: bool | list[SchemathesisWarning] | None = None,
     ) -> None:
         if base_url is not None:
             _validate_base_url(base_url)
@@ -220,9 +236,15 @@ class ProjectConfig(DiffBase):
         if proxy is not None:
             self.proxy = proxy
 
+        if parameters is not None:
+            self.parameters = parameters
+
         if suppress_health_check is not None:
             self.suppress_health_check = suppress_health_check
 
+        if warnings is not None:
+            self._set_warnings(warnings)
+
     def auth_for(self, *, operation: APIOperation | None = None) -> tuple[str, str] | None:
         """Get auth credentials, prioritizing operation-specific configs."""
         if operation is not None:
@@ -233,7 +255,7 @@ class ProjectConfig(DiffBase):
             return self.auth.basic
         return None
 
-    def headers_for(self, *, operation: APIOperation | None = None) -> dict[str, str] | None:
+    def headers_for(self, *, operation: APIOperation | None = None) -> dict[str, str]:
         """Get explicitly configured headers."""
         headers = self.headers.copy() if self.headers else {}
         if operation is not None:
@@ -291,6 +313,16 @@ class ProjectConfig(DiffBase):
             return self.rate_limit
         return None
 
+    def warnings_for(self, *, operation: APIOperation | None = None) -> list[SchemathesisWarning]:
+        # Operation can be absent on some non-fatal errors due to schema parsing
+        if operation is not None:
+            config = self.operations.get_for_operation(operation=operation)
+            if config.warnings is not None:
+                return config.warnings
+        if self.warnings is None:
+            return list(SchemathesisWarning)
+        return self.warnings
+
     def phases_for(self, *, operation: APIOperation | None) -> PhasesConfig:
         configs = []
         if operation is not None:

schemathesis/config/_report.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import datetime
 from dataclasses import dataclass
 from enum import Enum
 from pathlib import Path
@@ -55,8 +56,9 @@ class ReportsConfig(DiffBase):
     junit: ReportConfig
     vcr: ReportConfig
     har: ReportConfig
+    _timestamp: str
 
-    __slots__ = ("directory", "preserve_bytes", "junit", "vcr", "har")
+    __slots__ = ("directory", "preserve_bytes", "junit", "vcr", "har", "_timestamp")
 
     def __init__(
         self,
@@ -72,6 +74,7 @@ class ReportsConfig(DiffBase):
         self.junit = junit or ReportConfig()
         self.vcr = vcr or ReportConfig()
         self.har = har or ReportConfig()
+        self._timestamp = datetime.datetime.now().strftime("%Y%m%dT%H%M%SZ")
 
     @classmethod
     def from_dict(cls, data: dict[str, Any]) -> ReportsConfig:
@@ -113,4 +116,5 @@ class ReportsConfig(DiffBase):
         report: ReportConfig = getattr(self, format.value)
         if report.path is not None:
             return report.path
-        return self.directory / f"{format.value}.{format.extension}"
+
+        return self.directory / f"{format.value}-{self._timestamp}.{format.extension}"

schemathesis/config/_warnings.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+import enum
+
+from schemathesis.config._env import resolve
+
+
+class SchemathesisWarning(str, enum.Enum):
+    MISSING_AUTH = "missing_auth"
+    MISSING_TEST_DATA = "missing_test_data"
+    VALIDATION_MISMATCH = "validation_mismatch"
+
+    @classmethod
+    def from_str(cls, value: str) -> SchemathesisWarning:
+        return {
+            "missing_auth": cls.MISSING_AUTH,
+            "missing_test_data": cls.MISSING_TEST_DATA,
+            "validation_mismatch": cls.VALIDATION_MISMATCH,
+        }[value.lower()]
+
+
+def resolve_warnings(value: bool | list[str] | None) -> bool | list[SchemathesisWarning] | None:
+    if isinstance(value, list):
+        return [SchemathesisWarning.from_str(resolve(item)) for item in value]
+    return value

schemathesis/config/schema.json

@@ -121,6 +121,9 @@
     },
     "request-cert-key": {
       "type": "string"
+    },
+    "warnings": {
+      "$ref": "#/$defs/WarningConfig"
     }
   },
   "$defs": {
@@ -242,7 +245,7 @@
       "additionalProperties": false,
       "properties": {
         "examples": {
-          "$ref": "#/$defs/PhaseConfig"
+          "$ref": "#/$defs/ExamplesPhaseConfig"
         },
         "coverage": {
           "$ref": "#/$defs/CoveragePhaseConfig"
@@ -270,6 +273,24 @@
         }
       }
     },
+    "ExamplesPhaseConfig": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "enabled": {
+          "type": "boolean"
+        },
+        "fill-missing": {
+          "type": "boolean"
+        },
+        "generation": {
+          "$ref": "#/$defs/GenerationConfig"
+        },
+        "checks": {
+          "$ref": "#/$defs/ChecksConfig"
+        }
+      }
+    },
     "StatefulPhaseConfig": {
       "type": "object",
       "additionalProperties": false,
@@ -296,6 +317,9 @@
         "enabled": {
           "type": "boolean"
         },
+        "generate-duplicate-query-parameters": {
+          "type": "boolean"
+        },
         "unexpected-methods": {
           "type": "array",
           "items": {
@@ -494,12 +518,33 @@
         },
         "request-cert-key": {
           "type": "string"
+        },
+        "warnings": {
+          "$ref": "#/$defs/WarningConfig"
         }
       },
       "required": [
         "title"
       ]
     },
+    "WarningConfig": {
+      "anyOf": [
+        {
+          "type": "boolean"
+        },
+        {
+          "type": "array",
+          "uniqueItems": true,
+          "items": {
+            "enum": [
+              "missing_auth",
+              "missing_test_data",
+              "validation_mismatch"
+            ]
+          }
+        }
+      ]
+    },
     "OperationConfig": {
       "type": "object",
       "additionalProperties": false,
@@ -541,6 +586,9 @@
         "request-cert-key": {
           "type": "string"
         },
+        "warnings": {
+          "$ref": "#/$defs/WarningConfig"
+        },
         "checks": {
           "$ref": "#/$defs/ChecksConfig"
         },

schemathesis/core/errors.py

@@ -20,10 +20,16 @@ if TYPE_CHECKING:
 
 
 SCHEMA_ERROR_SUGGESTION = "Ensure that the definition complies with the OpenAPI specification"
-SERIALIZERS_SUGGESTION_MESSAGE = (
-    "You can register your own serializer with `schemathesis.serializer` "
-    "and Schemathesis will be able to make API calls with this media type. \n"
-    "See https://schemathesis.readthedocs.io/en/stable/how.html#payload-serialization for more information."
+SERIALIZERS_DOCUMENTATION_URL = "https://schemathesis.readthedocs.io/en/latest/guides/custom-serializers/"
+SERIALIZERS_SUGGESTION_MESSAGE = f"Check your schema or add custom serializers: {SERIALIZERS_DOCUMENTATION_URL}"
+SERIALIZATION_NOT_POSSIBLE_MESSAGE = f"No supported serializers for media types: {{}}\n{SERIALIZERS_SUGGESTION_MESSAGE}"
+SERIALIZATION_FOR_TYPE_IS_NOT_POSSIBLE_MESSAGE = (
+    f"Cannot serialize to '{{}}' (unsupported media type)\n{SERIALIZERS_SUGGESTION_MESSAGE}"
+)
+RECURSIVE_REFERENCE_ERROR_MESSAGE = (
+    "Currently, Schemathesis can't generate data for this operation due to "
+    "recursive references in the operation definition. See more information in "
+    "this issue - https://github.com/schemathesis/schemathesis/issues/947"
 )
 
 
@@ -277,19 +283,6 @@ class UnboundPrefix(SerializationError):
         super().__init__(UNBOUND_PREFIX_MESSAGE_TEMPLATE.format(prefix=prefix))
 
 
-SERIALIZATION_NOT_POSSIBLE_MESSAGE = (
-    f"Schemathesis can't serialize data to any of the defined media types: {{}} \n{SERIALIZERS_SUGGESTION_MESSAGE}"
-)
-SERIALIZATION_FOR_TYPE_IS_NOT_POSSIBLE_MESSAGE = (
-    f"Schemathesis can't serialize data to {{}} \n{SERIALIZERS_SUGGESTION_MESSAGE}"
-)
-RECURSIVE_REFERENCE_ERROR_MESSAGE = (
-    "Currently, Schemathesis can't generate data for this operation due to "
-    "recursive references in the operation definition. See more information in "
-    "this issue - https://github.com/schemathesis/schemathesis/issues/947"
-)
-
-
 class SerializationNotPossible(SerializationError):
     """Not possible to serialize data to specified media type(s).
 
@@ -403,7 +396,10 @@ def get_request_error_extras(exc: RequestException) -> list[str]:
             return [reason.strip()]
         return [" ".join(map(_clean_inner_request_message, inner.args))]
     if isinstance(exc, ChunkedEncodingError):
-        return [str(exc.args[0].args[1])]
+        args = exc.args[0].args
+        if len(args) == 1:
+            return [str(args[0])]
+        return [str(args[1])]
     return []
 
 
@@ -438,7 +434,7 @@ def split_traceback(traceback: str) -> list[str]:
 
 
 def format_exception(
-    error: Exception,
+    error: BaseException,
     *,
     with_traceback: bool = False,
     skip_frames: int = 0,

schemathesis/core/transport.py

@@ -7,7 +7,11 @@ from typing import TYPE_CHECKING, Any, Mapping
 from schemathesis.core.version import SCHEMATHESIS_VERSION
 
 if TYPE_CHECKING:
+    import httpx
     import requests
+    from werkzeug.test import TestResponse
+
+    from schemathesis.generation.overrides import Override
 
 USER_AGENT = f"schemathesis/{SCHEMATHESIS_VERSION}"
 DEFAULT_RESPONSE_TIMEOUT = 10
@@ -27,7 +31,31 @@ def prepare_urlencoded(data: Any) -> Any:
 
 
 class Response:
-    """Unified response for both testing and reporting purposes."""
+    """HTTP response wrapper that normalizes different transport implementations.
+
+    Provides a consistent interface for accessing response data whether the request
+    was made via HTTP, ASGI, or WSGI transports.
+    """
+
+    status_code: int
+    """HTTP status code (e.g., 200, 404, 500)."""
+    headers: dict[str, list[str]]
+    """Response headers with lowercase keys and list values."""
+    content: bytes
+    """Raw response body as bytes."""
+    request: requests.PreparedRequest
+    """The request that generated this response."""
+    elapsed: float
+    """Response time in seconds."""
+    verify: bool
+    """Whether TLS verification was enabled for the request."""
+    message: str
+    """HTTP status message (e.g., "OK", "Not Found")."""
+    http_version: str
+    """HTTP protocol version ("1.0" or "1.1")."""
+    encoding: str | None
+    """Character encoding for text content, if detected."""
+    _override: Override | None
 
     __slots__ = (
         "status_code",
@@ -41,6 +69,7 @@ class Response:
         "http_version",
         "encoding",
         "_encoded_body",
+        "_override",
     )
 
     def __init__(
@@ -54,6 +83,7 @@ class Response:
         message: str = "",
         http_version: str = "1.1",
         encoding: str | None = None,
+        _override: Override | None = None,
     ):
         self.status_code = status_code
         self.headers = {key.lower(): value for key, value in headers.items()}
@@ -67,9 +97,24 @@ class Response:
         self.message = message
         self.http_version = http_version
         self.encoding = encoding
+        self._override = _override
 
     @classmethod
-    def from_requests(cls, response: requests.Response, verify: bool) -> Response:
+    def from_any(cls, response: Response | httpx.Response | requests.Response | TestResponse) -> Response:
+        import httpx
+        import requests
+        from werkzeug.test import TestResponse
+
+        if isinstance(response, requests.Response):
+            return Response.from_requests(response, verify=True)
+        elif isinstance(response, httpx.Response):
+            return Response.from_httpx(response, verify=True)
+        elif isinstance(response, TestResponse):
+            return Response.from_wsgi(response)
+        return response
+
+    @classmethod
+    def from_requests(cls, response: requests.Response, verify: bool, _override: Override | None = None) -> Response:
         raw = response.raw
         raw_headers = raw.headers if raw is not None else {}
         headers = {name: response.raw.headers.getlist(name) for name in raw_headers.keys()}
@@ -86,23 +131,93 @@ class Response:
             encoding=response.encoding,
             http_version=http_version,
             verify=verify,
+            _override=_override,
+        )
+
+    @classmethod
+    def from_httpx(cls, response: httpx.Response, verify: bool) -> Response:
+        import requests
+
+        request = requests.Request(
+            method=response.request.method,
+            url=str(response.request.url),
+            headers=dict(response.request.headers),
+            params=dict(response.request.url.params),
+            data=response.request.content,
+        ).prepare()
+        return Response(
+            status_code=response.status_code,
+            headers={key: [value] for key, value in response.headers.items()},
+            content=response.content,
+            request=request,
+            elapsed=response.elapsed.total_seconds(),
+            message=response.reason_phrase,
+            encoding=response.encoding,
+            http_version=response.http_version,
+            verify=verify,
+        )
+
+    @classmethod
+    def from_wsgi(cls, response: TestResponse) -> Response:
+        import http.client
+
+        import requests
+
+        reason = http.client.responses.get(response.status_code, "Unknown")
+        data = response.get_data()
+        if response.response == []:
+            # 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
+        request = requests.Request(
+            method=response.request.method,
+            url=str(response.request.url),
+            headers=dict(response.request.headers),
+            params=dict(response.request.args),
+            # Request body is not available
+            data=b"",
+        ).prepare()
+        return Response(
+            status_code=response.status_code,
+            headers={name: response.headers.getlist(name) for name in response.headers.keys()},
+            content=data,
+            request=request,
+            # Elapsed time is not available
+            elapsed=0.0,
+            message=reason,
+            encoding=encoding,
+            http_version="1.1",
+            verify=False,
         )
 
     @property
     def text(self) -> str:
+        """Decode response content as text using the detected or default encoding."""
         return self.content.decode(self.encoding if self.encoding else "utf-8")
 
     def json(self) -> Any:
+        """Parse response content as JSON.
+
+        Returns:
+            Parsed JSON data (dict, list, or primitive types)
+
+        Raises:
+            json.JSONDecodeError: If content is not valid JSON
+
+        """
         if self._json is None:
             self._json = json.loads(self.text)
         return self._json
 
     @property
     def body_size(self) -> int | None:
+        """Size of response body in bytes, or None if no content."""
         return len(self.content) if self.content else None
 
     @property
     def encoded_body(self) -> str | None:
+        """Base64-encoded response body for binary-safe serialization."""
         if self._encoded_body is None and self.content:
             self._encoded_body = base64.b64encode(self.content).decode()
         return self._encoded_body

schemathesis/engine/context.py

@@ -80,6 +80,7 @@ class EngineContext:
         import requests
 
         session = requests.Session()
+        session.headers = {}
         config = self.config
 
         session.verify = config.tls_verify_for(operation=operation)