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

schemathesis/runner/serialization.py

@@ -2,39 +2,46 @@
 
 They all consist of primitive types and don't have references to schemas, app, etc.
 """
+
 from __future__ import annotations
+
 import logging
 import re
-from dataclasses import dataclass, field
-from typing import Any, TYPE_CHECKING, cast
+import textwrap
+from dataclasses import asdict, dataclass, field
+from typing import TYPE_CHECKING, Any, cast
 
-from ..transports import serialize_payload
 from ..code_samples import get_excluded_headers
 from ..exceptions import (
-    FailureContext,
-    InternalError,
-    make_unique_by_key,
-    format_exception,
-    extract_requests_exception_details,
-    RuntimeErrorType,
-    DeadlineExceeded,
-    OperationSchemaError,
     BodyInGetRequestError,
+    DeadlineExceeded,
+    InternalError,
     InvalidRegularExpression,
+    OperationSchemaError,
+    RecursiveReferenceError,
+    RuntimeErrorType,
     SerializationError,
     UnboundPrefixError,
+    extract_requests_exception_details,
+    format_exception,
+    make_unique_by_key,
 )
-from ..models import Case, Check, Interaction, Request, Response, Status, TestResult
+from ..models import Case, Check, Interaction, Request, Response, Status, TestPhase, TestResult, TransitionId
+from ..transports import deserialize_payload, serialize_payload
 
 if TYPE_CHECKING:
     import hypothesis.errors
     from requests.structures import CaseInsensitiveDict
 
+    from ..failures import FailureContext
+    from ..generation import DataGenerationMethod
+
 
 @dataclass
 class SerializedCase:
     # Case data
     id: str
+    generation_time: float
     path_parameters: dict[str, Any] | None
     headers: dict[str, Any] | None
     cookies: dict[str, Any] | None
@@ -46,7 +53,9 @@ class SerializedCase:
     method: str
     url: str
     path_template: str
+    full_path: str
     verbose_name: str
+    transition_id: TransitionId | None
     # Transport info
     verify: bool
     # Headers coming from sources outside data generation
@@ -59,6 +68,7 @@ class SerializedCase:
         serialized_body = _serialize_body(request_data.body)
         return cls(
             id=case.id,
+            generation_time=case.generation_time,
             path_parameters=case.path_parameters,
             headers=dict(case.headers) if case.headers is not None else None,
             cookies=case.cookies,
@@ -71,11 +81,21 @@ class SerializedCase:
             method=case.method,
             url=request_data.url,
             path_template=case.path,
+            full_path=case.full_path,
             verbose_name=case.operation.verbose_name,
+            transition_id=case.source.transition_id if case.source is not None else None,
             verify=verify,
             extra_headers=request_data.headers,
         )
 
+    def deserialize_body(self) -> bytes | None:
+        """Deserialize the test case body.
+
+        `SerializedCase` should be serializable to JSON, therefore body is encoded as base64 string
+        to support arbitrary binary data.
+        """
+        return deserialize_payload(self.body)
+
 
 def _serialize_body(body: str | bytes | None) -> str | None:
     if body is None:
@@ -105,6 +125,7 @@ class SerializedCheck:
     @classmethod
     def from_check(cls, check: Check) -> SerializedCheck:
         import requests
+
         from ..transports.responses import WSGIResponse
 
         if check.response is not None:
@@ -137,9 +158,32 @@ class SerializedCheck:
             history=history,
         )
 
+    @property
+    def title(self) -> str:
+        if self.context is not None:
+            return self.context.title
+        return f"Custom check failed: `{self.name}`"
+
+    @property
+    def formatted_message(self) -> str | None:
+        if self.context is not None:
+            if self.context.message:
+                message = self.context.message
+            else:
+                message = None
+        else:
+            message = self.message
+        if message is not None:
+            message = textwrap.indent(message, prefix="    ")
+        return message
+
 
 def _get_headers(headers: dict[str, Any] | CaseInsensitiveDict) -> dict[str, str]:
-    return {key: value[0] for key, value in headers.items() if key not in get_excluded_headers()}
+    return {
+        key: value[0] if isinstance(value, list) else value
+        for key, value in headers.items()
+        if key not in get_excluded_headers()
+    }
 
 
 @dataclass
@@ -200,8 +244,8 @@ class SerializedError:
 
     @classmethod
     def from_exception(cls, exception: Exception) -> SerializedError:
-        import requests
         import hypothesis.errors
+        import requests
         from hypothesis import HealthCheck
 
         title = "Runtime Error"
@@ -219,6 +263,11 @@ class SerializedError:
             type_ = RuntimeErrorType.HYPOTHESIS_DEADLINE_EXCEEDED
             message = str(exception).strip()
             extras = []
+        elif isinstance(exception, RecursiveReferenceError):
+            type_ = RuntimeErrorType.SCHEMA_UNSUPPORTED
+            message = str(exception).strip()
+            extras = []
+            title = "Unsupported Schema"
         elif isinstance(exception, hypothesis.errors.InvalidArgument) and str(exception).startswith("Scalar "):
             # Comes from `hypothesis-graphql`
             scalar_name = _scalar_name_from_error(exception)
@@ -226,8 +275,10 @@ class SerializedError:
             message = f"Scalar type '{scalar_name}' is not recognized"
             extras = []
             title = "Unknown GraphQL Scalar"
-        elif isinstance(exception, hypothesis.errors.InvalidArgument) and str(exception).endswith(
-            "larger than Hypothesis is designed to handle"
+        elif (
+            isinstance(exception, hypothesis.errors.InvalidArgument)
+            and str(exception).endswith("larger than Hypothesis is designed to handle")
+            or "can never generate an example, because min_size is larger than Hypothesis supports" in str(exception)
         ):
             type_ = RuntimeErrorType.HYPOTHESIS_HEALTH_CHECK_LARGE_BASE_EXAMPLE
             message = HEALTH_CHECK_MESSAGE_LARGE_BASE_EXAMPLE
@@ -238,6 +289,7 @@ class SerializedError:
             message = f"{exception}. Possible reasons:"
             extras = [
                 "- Contradictory schema constraints, such as a minimum value exceeding the maximum.",
+                "- Invalid schema definitions for headers or cookies, for example allowing for non-ASCII characters.",
                 "- Excessive schema complexity, which hinders parameter generation.",
             ]
             title = "Schema Error"
@@ -339,9 +391,15 @@ def _scalar_name_from_error(exception: hypothesis.errors.InvalidArgument) -> str
 @dataclass
 class SerializedInteraction:
     request: Request
-    response: Response
+    response: Response | None
     checks: list[SerializedCheck]
     status: Status
+    data_generation_method: DataGenerationMethod
+    phase: TestPhase | None
+    description: str | None
+    location: str | None
+    parameter: str | None
+    parameter_location: str | None
     recorded_at: str
 
     @classmethod
@@ -351,6 +409,12 @@ class SerializedInteraction:
             response=interaction.response,
             checks=[SerializedCheck.from_check(check) for check in interaction.checks],
             status=interaction.status,
+            data_generation_method=interaction.data_generation_method,
+            phase=interaction.phase,
+            description=interaction.description,
+            location=interaction.location,
+            parameter=interaction.parameter,
+            parameter_location=interaction.parameter_location,
             recorded_at=interaction.recorded_at,
         )
 
@@ -409,3 +473,72 @@ def deduplicate_failures(checks: list[SerializedCheck]) -> list[SerializedCheck]
                 unique_checks.append(check)
                 seen.add(key)
     return unique_checks
+
+
+def _serialize_case(case: SerializedCase) -> dict[str, Any]:
+    return {
+        "id": case.id,
+        "generation_time": case.generation_time,
+        "verbose_name": case.verbose_name,
+        "path_template": case.path_template,
+        "path_parameters": stringify_path_parameters(case.path_parameters),
+        "query": prepare_query(case.query),
+        "cookies": case.cookies,
+        "media_type": case.media_type,
+    }
+
+
+def _serialize_response(response: Response) -> dict[str, Any]:
+    return {
+        "status_code": response.status_code,
+        "headers": response.headers,
+        "body": response.body,
+        "encoding": response.encoding,
+        "elapsed": response.elapsed,
+    }
+
+
+def _serialize_check(check: SerializedCheck) -> dict[str, Any]:
+    return {
+        "name": check.name,
+        "value": check.value,
+        "request": {
+            "method": check.request.method,
+            "uri": check.request.uri,
+            "body": check.request.body,
+            "headers": check.request.headers,
+        },
+        "response": _serialize_response(check.response) if check.response is not None else None,
+        "example": _serialize_case(check.example),
+        "message": check.message,
+        "context": asdict(check.context) if check.context is not None else None,  # type: ignore
+        "history": [
+            {"case": _serialize_case(entry.case), "response": _serialize_response(entry.response)}
+            for entry in check.history
+        ],
+    }
+
+
+def stringify_path_parameters(path_parameters: dict[str, Any] | None) -> dict[str, str]:
+    """Cast all path parameter values to strings.
+
+    Path parameter values may be of arbitrary type, but to display them properly they should be casted to strings.
+    """
+    return {key: str(value) for key, value in (path_parameters or {}).items()}
+
+
+def prepare_query(query: dict[str, Any] | None) -> dict[str, list[str]]:
+    """Convert all query values to list of strings.
+
+    Query parameters may be generated in different shapes, including integers, strings, list of strings, etc.
+    It can also be an object, if the schema contains an object, but `style` and `explode` combo is not applicable.
+    """
+
+    def to_list_of_strings(value: Any) -> list[str]:
+        if isinstance(value, list):
+            return list(map(str, value))
+        if isinstance(value, str):
+            return [value]
+        return [str(value)]
+
+    return {key: to_list_of_strings(value) for key, value in (query or {}).items()}

schemathesis/sanitization.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 import threading
 from collections.abc import MutableMapping, MutableSequence
 from dataclasses import dataclass, replace
@@ -9,6 +10,7 @@ from .constants import NOT_SET
 
 if TYPE_CHECKING:
     from requests import PreparedRequest
+
     from .models import Case, CaseSource, Request
     from .runner.serialization import SerializedCase, SerializedCheck, SerializedInteraction
     from .transports.responses import GenericResponse
@@ -236,6 +238,7 @@ def sanitize_serialized_check(check: SerializedCheck, *, config: Config | None =
 
 
 def sanitize_serialized_case(case: SerializedCase, *, config: Config | None = None) -> None:
+    case.url = sanitize_url(case.url, config=config)
     for value in (case.path_parameters, case.headers, case.cookies, case.query, case.extra_headers):
         if value is not None:
             sanitize_value(value, config=config)
@@ -243,6 +246,7 @@ def sanitize_serialized_case(case: SerializedCase, *, config: Config | None = No
 
 def sanitize_serialized_interaction(interaction: SerializedInteraction, *, config: Config | None = None) -> None:
     sanitize_request(interaction.request, config=config)
-    sanitize_value(interaction.response.headers, config=config)
+    if interaction.response is not None:
+        sanitize_value(interaction.response.headers, config=config)
     for check in interaction.checks:
         sanitize_serialized_check(check, config=config)