schemathesis 4.0.0a11__py3-none-any.whl → 4.0.0a12__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,
         *,
@@ -180,6 +194,7 @@ class ProjectConfig(DiffBase):
         request_cert_key: str | 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)
@@ -223,6 +238,9 @@ class ProjectConfig(DiffBase):
         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:
@@ -291,6 +309,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

@@ -403,7 +403,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 +441,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

@@ -27,7 +27,30 @@ 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."""
 
     __slots__ = (
         "status_code",
@@ -90,19 +113,31 @@ class Response:
 
     @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)

schemathesis/engine/errors.py

@@ -8,6 +8,7 @@ from __future__ import annotations
 
 import enum
 import re
+from dataclasses import dataclass
 from functools import cached_property
 from typing import TYPE_CHECKING, Callable, Iterator, Sequence, cast
 
@@ -24,6 +25,8 @@ from schemathesis.core.errors import (
 
 if TYPE_CHECKING:
     import hypothesis.errors
+    import requests
+    from requests.exceptions import ChunkedEncodingError
 
 __all__ = ["EngineErrorInfo", "DeadlineExceeded", "UnsupportedRecursiveReference", "UnexpectedError"]
 
@@ -61,8 +64,9 @@ class EngineErrorInfo:
     It serves as a caching wrapper around exceptions to avoid repeated computations.
     """
 
-    def __init__(self, error: Exception) -> None:
+    def __init__(self, error: Exception, code_sample: str | None = None) -> None:
         self._error = error
+        self._code_sample = code_sample
 
     def __str__(self) -> str:
         return self._error_repr
@@ -212,6 +216,9 @@ class EngineErrorInfo:
             message.append("")  # Empty line before extras
             message.extend(f"{indent}{extra}" for extra in extras)
 
+        if self._code_sample is not None:
+            message.append(f"\nReproduce with: \n\n    {self._code_sample}")
+
         # Suggestion
         suggestion = get_runtime_error_suggestion(self._kind, bold=bold)
         if suggestion is not None:
@@ -403,3 +410,55 @@ def canonicalize_error_message(error: Exception, with_traceback: bool = True) ->
     message = MEMORY_ADDRESS_RE.sub("0xbaaaaaaaaaad", message)
     # Remove URL information
     return URL_IN_ERROR_MESSAGE_RE.sub("", message)
+
+
+def clear_hypothesis_notes(exc: Exception) -> None:
+    notes = getattr(exc, "__notes__", [])
+    if any("while generating" in note for note in notes):
+        notes.clear()
+
+
+def is_unrecoverable_network_error(exc: Exception) -> bool:
+    from http.client import RemoteDisconnected
+
+    from urllib3.exceptions import ProtocolError
+
+    def has_connection_reset(inner: BaseException) -> bool:
+        exc_str = str(inner)
+        if any(pattern in exc_str for pattern in ["Connection reset by peer", "[Errno 104]", "ECONNRESET"]):
+            return True
+
+        if inner.__context__ is not None:
+            return has_connection_reset(inner.__context__)
+
+        return False
+
+    if isinstance(exc.__context__, ProtocolError):
+        if len(exc.__context__.args) == 2 and isinstance(exc.__context__.args[1], RemoteDisconnected):
+            return True
+        if len(exc.__context__.args) == 1 and exc.__context__.args[0] == "Response ended prematurely":
+            return True
+
+    return has_connection_reset(exc)
+
+
+@dataclass()
+class UnrecoverableNetworkError:
+    error: requests.ConnectionError | ChunkedEncodingError
+    code_sample: str
+
+    __slots__ = ("error", "code_sample")
+
+    def __init__(self, error: requests.ConnectionError | ChunkedEncodingError, code_sample: str) -> None:
+        self.error = error
+        self.code_sample = code_sample
+
+
+@dataclass
+class TestingState:
+    unrecoverable_network_error: UnrecoverableNetworkError | None
+
+    __slots__ = ("unrecoverable_network_error",)
+
+    def __init__(self) -> None:
+        self.unrecoverable_network_error = None

schemathesis/engine/events.py

@@ -200,10 +200,18 @@ class NonFatalError(EngineEvent):
 
     __slots__ = ("id", "timestamp", "info", "value", "phase", "label", "related_to_operation")
 
-    def __init__(self, *, error: Exception, phase: PhaseName, label: str, related_to_operation: bool) -> None:
+    def __init__(
+        self,
+        *,
+        error: Exception,
+        phase: PhaseName,
+        label: str,
+        related_to_operation: bool,
+        code_sample: str | None = None,
+    ) -> None:
         self.id = uuid.uuid4()
         self.timestamp = time.time()
-        self.info = EngineErrorInfo(error=error)
+        self.info = EngineErrorInfo(error=error, code_sample=code_sample)
         self.value = error
         self.phase = phase
         self.label = label

schemathesis/engine/phases/probes.py

@@ -16,6 +16,7 @@ from typing import TYPE_CHECKING
 from schemathesis.core.result import Err, Ok, Result
 from schemathesis.core.transport import USER_AGENT
 from schemathesis.engine import Status, events
+from schemathesis.transport.prepare import get_default_headers
 
 if TYPE_CHECKING:
     import requests
@@ -134,6 +135,8 @@ def send(probe: Probe, ctx: EngineContext) -> ProbeRun:
         request = probe.prepare_request(session, Request(), ctx.schema)
         request.headers[HEADER_NAME] = probe.name
         request.headers["User-Agent"] = USER_AGENT
+        for header, value in get_default_headers().items():
+            request.headers.setdefault(header, value)
         with warnings.catch_warnings():
             warnings.simplefilter("ignore", InsecureRequestWarning)
             response = session.send(request, timeout=ctx.config.request_timeout or 2)

schemathesis/engine/phases/stateful/__init__.py

@@ -6,6 +6,7 @@ from typing import TYPE_CHECKING
 
 from schemathesis.engine import Status, events
 from schemathesis.engine.phases import Phase, PhaseName, PhaseSkipReason
+from schemathesis.generation.stateful import STATEFUL_TESTS_LABEL
 
 if TYPE_CHECKING:
     from schemathesis.engine.context import EngineContext
@@ -19,7 +20,7 @@ def execute(engine: EngineContext, phase: Phase) -> events.EventGenerator:
     try:
         state_machine = engine.schema.as_state_machine()
     except Exception as exc:
-        yield events.NonFatalError(error=exc, phase=phase.name, label="Stateful tests", related_to_operation=False)
+        yield events.NonFatalError(error=exc, phase=phase.name, label=STATEFUL_TESTS_LABEL, related_to_operation=False)
         yield events.PhaseFinished(phase=phase, status=Status.ERROR, payload=None)
         return