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

schemathesis/service/serialization.py

@@ -1,11 +1,14 @@
 from __future__ import annotations
+
 from dataclasses import asdict
-from typing import Any, Callable, Dict, Optional, TypeVar, cast
+from typing import TYPE_CHECKING, Any, Callable, Dict, Optional, TypeVar, cast
 
-from ..models import Response
-from ..runner import events
-from ..runner.serialization import SerializedCase
 from ..internal.transformation import merge_recursively
+from ..runner import events
+from ..runner.serialization import _serialize_check
+
+if TYPE_CHECKING:
+    from ..stateful import events as stateful_events
 
 S = TypeVar("S", bound=events.ExecutionEvent)
 SerializeFunc = Callable[[S], Optional[Dict[str, Any]]]
@@ -19,32 +22,28 @@ def serialize_initialized(event: events.Initialized) -> dict[str, Any] | None:
     }
 
 
-def serialize_before_execution(event: events.BeforeExecution) -> dict[str, Any] | None:
-    return {
-        "correlation_id": event.correlation_id,
-        "verbose_name": event.verbose_name,
-        "data_generation_method": event.data_generation_method,
-    }
+def serialize_before_probing(_: events.BeforeProbing) -> None:
+    return None
 
 
-def _serialize_case(case: SerializedCase) -> dict[str, Any]:
-    return {
-        "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_after_probing(event: events.AfterProbing) -> dict[str, Any] | None:
+    probes = event.probes or []
+    return {"probes": [probe.serialize() for probe in probes]}
+
+
+def serialize_before_analysis(_: events.BeforeAnalysis) -> None:
+    return None
 
 
-def _serialize_response(response: Response) -> dict[str, Any]:
+def serialize_after_analysis(event: events.AfterAnalysis) -> dict[str, Any] | None:
+    return event._serialize()
+
+
+def serialize_before_execution(event: events.BeforeExecution) -> dict[str, Any] | None:
     return {
-        "status_code": response.status_code,
-        "headers": response.headers,
-        "body": response.body,
-        "encoding": response.encoding,
-        "elapsed": response.elapsed,
+        "correlation_id": event.correlation_id,
+        "verbose_name": event.verbose_name,
+        "data_generation_method": event.data_generation_method,
     }
 
 
@@ -56,27 +55,7 @@ def serialize_after_execution(event: events.AfterExecution) -> dict[str, Any] |
         "elapsed_time": event.elapsed_time,
         "data_generation_method": event.data_generation_method,
         "result": {
-            "checks": [
-                {
-                    "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
-                    ],
-                }
-                for check in event.result.checks
-            ],
+            "checks": [_serialize_check(check) for check in event.result.checks],
             "errors": [asdict(error) for error in event.result.errors],
             "skip_reason": event.result.skip_reason,
         },
@@ -114,12 +93,35 @@ def serialize_finished(event: events.Finished) -> dict[str, Any] | None:
     }
 
 
+def serialize_stateful_event(event: events.StatefulEvent) -> dict[str, Any] | None:
+    return _serialize_stateful_event(event.data)
+
+
+def _serialize_stateful_event(event: stateful_events.StatefulEvent) -> dict[str, Any] | None:
+    return {"data": {event.__class__.__name__: event.asdict()}}
+
+
+def serialize_after_stateful_execution(event: events.AfterStatefulExecution) -> dict[str, Any] | None:
+    return {
+        "status": event.status,
+        "data_generation_method": event.data_generation_method,
+        "result": asdict(event.result),
+        "elapsed_time": event.elapsed_time,
+    }
+
+
 SERIALIZER_MAP = {
     events.Initialized: serialize_initialized,
+    events.BeforeProbing: serialize_before_probing,
+    events.AfterProbing: serialize_after_probing,
+    events.BeforeAnalysis: serialize_before_analysis,
+    events.AfterAnalysis: serialize_after_analysis,
     events.BeforeExecution: serialize_before_execution,
     events.AfterExecution: serialize_after_execution,
     events.Interrupted: serialize_interrupted,
     events.InternalError: serialize_internal_error,
+    events.StatefulEvent: serialize_stateful_event,
+    events.AfterStatefulExecution: serialize_after_stateful_execution,
     events.Finished: serialize_finished,
 }
 
@@ -128,10 +130,16 @@ def serialize_event(
     event: events.ExecutionEvent,
     *,
     on_initialized: SerializeFunc | None = None,
+    on_before_probing: SerializeFunc | None = None,
+    on_after_probing: SerializeFunc | None = None,
+    on_before_analysis: SerializeFunc | None = None,
+    on_after_analysis: SerializeFunc | None = None,
     on_before_execution: SerializeFunc | None = None,
     on_after_execution: SerializeFunc | None = None,
     on_interrupted: SerializeFunc | None = None,
     on_internal_error: SerializeFunc | None = None,
+    on_stateful_event: SerializeFunc | None = None,
+    on_after_stateful_execution: SerializeFunc | None = None,
     on_finished: SerializeFunc | None = None,
     extra: dict[str, Any] | None = None,
 ) -> dict[str, dict[str, Any] | None]:
@@ -139,10 +147,16 @@ def serialize_event(
     # Use the explicitly provided serializer for this event and fallback to default one if it is not provided
     serializer = {
         events.Initialized: on_initialized,
+        events.BeforeProbing: on_before_probing,
+        events.AfterProbing: on_after_probing,
+        events.BeforeAnalysis: on_before_analysis,
+        events.AfterAnalysis: on_after_analysis,
         events.BeforeExecution: on_before_execution,
         events.AfterExecution: on_after_execution,
         events.Interrupted: on_interrupted,
         events.InternalError: on_internal_error,
+        events.StatefulEvent: on_stateful_event,
+        events.AfterStatefulExecution: on_after_stateful_execution,
         events.Finished: on_finished,
     }.get(event.__class__)
     if serializer is None:
@@ -157,28 +171,3 @@ def serialize_event(
             data = merge_recursively(data, extra)
     # Externally tagged structure
     return {event.__class__.__name__: data}
-
-
-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/service/usage.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 import sys
 from typing import Any
 

schemathesis/specs/graphql/_cache.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ...models import APIOperation
+    from ...schemas import APIOperationMap
+
+
+@dataclass
+class OperationCache:
+    _maps: dict[str, APIOperationMap] = field(default_factory=dict)
+    _operations: dict[str, APIOperation] = field(default_factory=dict)
+
+    def get_map(self, key: str) -> APIOperationMap | None:
+        return self._maps.get(key)
+
+    def insert_map(self, key: str, value: APIOperationMap) -> None:
+        self._maps[key] = value
+
+    def get_operation(self, key: str) -> APIOperation | None:
+        return self._operations.get(key)
+
+    def insert_operation(self, key: str, value: APIOperation) -> None:
+        self._operations[key] = value

schemathesis/specs/graphql/loaders.py

@@ -7,7 +7,7 @@ from json import JSONDecodeError
 from typing import IO, TYPE_CHECKING, Any, Callable, Dict, NoReturn, cast
 
 from ...code_samples import CodeSampleStyle
-from ...constants import WAIT_FOR_SCHEMA_INTERVAL
+from ...constants import DEFAULT_RESPONSE_TIMEOUT, WAIT_FOR_SCHEMA_INTERVAL
 from ...exceptions import SchemaError, SchemaErrorType
 from ...generation import (
     DEFAULT_DATA_GENERATION_METHODS,
@@ -16,11 +16,12 @@ from ...generation import (
     GenerationConfig,
 )
 from ...hooks import HookContext, dispatch
+from ...internal.output import OutputConfig
 from ...internal.validation import require_relative_url
 from ...loaders import load_schema_from_url
 from ...throttling import build_limiter
 from ...transports.headers import setup_default_headers
-from ...types import PathLike
+from ...types import PathLike, Specification
 
 if TYPE_CHECKING:
     from graphql import DocumentNode
@@ -52,6 +53,7 @@ def from_path(
     base_url: str | None = None,
     data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
     generation_config: GenerationConfig | None = None,
+    output_config: OutputConfig | None = None,
     code_sample_style: str = CodeSampleStyle.default().name,
     rate_limit: str | None = None,
     encoding: str = "utf8",
@@ -69,6 +71,8 @@ def from_path(
             base_url=base_url,
             data_generation_methods=data_generation_methods,
             code_sample_style=code_sample_style,
+            generation_config=generation_config,
+            output_config=output_config,
             location=pathlib.Path(path).absolute().as_uri(),
             rate_limit=rate_limit,
             sanitize_output=sanitize_output,
@@ -135,11 +139,12 @@ def from_url(
             interval=WAIT_FOR_SCHEMA_INTERVAL,
         )
         def _load_schema(_uri: str, **_kwargs: Any) -> requests.Response:
-            return requests.post(_uri, **kwargs)
+            return requests.post(_uri, **_kwargs)
 
     else:
         _load_schema = requests.post
 
+    kwargs.setdefault("timeout", DEFAULT_RESPONSE_TIMEOUT / 1000)
     response = load_schema_from_url(lambda: _load_schema(url, **kwargs))
     raw_schema = extract_schema_from_response(response)
     return from_dict(
@@ -161,6 +166,7 @@ def from_file(
     base_url: str | None = None,
     data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
     generation_config: GenerationConfig | None = None,
+    output_config: OutputConfig | None = None,
     code_sample_style: str = CodeSampleStyle.default().name,
     location: str | None = None,
     rate_limit: str | None = None,
@@ -198,6 +204,8 @@ def from_file(
         app=app,
         base_url=base_url,
         data_generation_methods=data_generation_methods,
+        generation_config=generation_config,
+        output_config=output_config,
         code_sample_style=code_sample_style,
         location=location,
         rate_limit=rate_limit,
@@ -221,6 +229,7 @@ def from_dict(
     location: str | None = None,
     data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
     generation_config: GenerationConfig | None = None,
+    output_config: OutputConfig | None = None,
     code_sample_style: str = CodeSampleStyle.default().name,
     rate_limit: str | None = None,
     sanitize_output: bool = True,
@@ -233,6 +242,7 @@ def from_dict(
     :param app: A WSGI app instance.
     :return: GraphQLSchema
     """
+    from ... import transports
     from .schemas import GraphQLSchema
 
     _code_sample_style = CodeSampleStyle.from_str(code_sample_style)
@@ -245,13 +255,17 @@ def from_dict(
         rate_limiter = build_limiter(rate_limit)
     instance = GraphQLSchema(
         raw_schema,
+        specification=Specification.GRAPHQL,
         location=location,
         base_url=base_url,
         app=app,
         data_generation_methods=DataGenerationMethod.ensure_list(data_generation_methods),
+        generation_config=generation_config or GenerationConfig(),
+        output_config=output_config or OutputConfig(),
         code_sample_style=_code_sample_style,
         rate_limiter=rate_limiter,
         sanitize_output=sanitize_output,
+        transport=transports.get(app),
     )  # type: ignore
     dispatch("after_load_schema", hook_context, instance)
     return instance
@@ -264,6 +278,7 @@ def from_wsgi(
     base_url: str | None = None,
     data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
     generation_config: GenerationConfig | None = None,
+    output_config: OutputConfig | None = None,
     code_sample_style: str = CodeSampleStyle.default().name,
     rate_limit: str | None = None,
     sanitize_output: bool = True,
@@ -292,6 +307,8 @@ def from_wsgi(
         base_url=base_url,
         app=app,
         data_generation_methods=data_generation_methods,
+        generation_config=generation_config,
+        output_config=output_config,
         code_sample_style=code_sample_style,
         rate_limit=rate_limit,
         sanitize_output=sanitize_output,
@@ -305,6 +322,7 @@ def from_asgi(
     base_url: str | None = None,
     data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
     generation_config: GenerationConfig | None = None,
+    output_config: OutputConfig | None = None,
     code_sample_style: str = CodeSampleStyle.default().name,
     rate_limit: str | None = None,
     sanitize_output: bool = True,
@@ -330,6 +348,8 @@ def from_asgi(
         base_url=base_url,
         app=app,
         data_generation_methods=data_generation_methods,
+        generation_config=generation_config,
+        output_config=output_config,
         code_sample_style=code_sample_style,
         rate_limit=rate_limit,
         sanitize_output=sanitize_output,
@@ -337,8 +357,8 @@ def from_asgi(
 
 
 def get_loader_for_app(app: Any) -> Callable:
-    from starlette.applications import Starlette
+    from ...transports.asgi import is_asgi_app
 
-    if isinstance(app, Starlette):
+    if is_asgi_app(app):
         return from_asgi
     return from_wsgi

schemathesis/specs/graphql/nodes.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:

schemathesis/specs/graphql/scalars.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 from functools import lru_cache
 from typing import TYPE_CHECKING
 
-
 from ...exceptions import UsageError
 
 if TYPE_CHECKING:
@@ -31,9 +30,10 @@ def scalar(name: str, strategy: st.SearchStrategy[graphql.ValueNode]) -> None:
 @lru_cache
 def get_extra_scalar_strategies() -> dict[str, st.SearchStrategy]:
     """Get all extra GraphQL strategies."""
-    from . import nodes
     from hypothesis import strategies as st
 
+    from . import nodes
+
     dates = st.dates().map(str)
     times = st.times().map("%sZ".__mod__)