schemathesis 3.29.2__py3-none-any.whl → 3.30.1__py3-none-any.whl

schemathesis/service/client.py

@@ -1,9 +1,10 @@
 from __future__ import annotations
-import json
+
 import hashlib
 import http
+import json
 from dataclasses import asdict
-from typing import Any, TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 from urllib.parse import urljoin
 
 import requests
@@ -14,19 +15,18 @@ from .ci import CIProvider
 from .constants import CI_PROVIDER_HEADER, REPORT_CORRELATION_ID_HEADER, REQUEST_TIMEOUT, UPLOAD_SOURCE_HEADER
 from .metadata import Metadata, collect_dependency_versions
 from .models import (
-    AnalysisSuccess,
     AnalysisError,
     AnalysisResult,
-    ProjectDetails,
+    AnalysisSuccess,
     AuthResponse,
     FailedUploadResponse,
-    UploadResponse,
-    UploadSource,
+    ProjectDetails,
     ProjectEnvironment,
     Specification,
+    UploadResponse,
+    UploadSource,
 )
 
-
 if TYPE_CHECKING:
     from ..runner import probes
 

schemathesis/service/events.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
+
 from dataclasses import dataclass
 
-from . import ci
 from ..exceptions import format_exception
+from . import ci
 
 
 class Event:

schemathesis/service/extensions.py

@@ -3,17 +3,17 @@ from __future__ import annotations
 import base64
 import re
 from ipaddress import IPv4Network, IPv6Network
-from typing import TYPE_CHECKING, Callable, Optional, Any
+from typing import TYPE_CHECKING, Any, Callable, Optional
 
 from ..graphql import nodes
-from ..internal.result import Result, Ok, Err
+from ..internal.result import Err, Ok, Result
 from .models import (
     Extension,
-    SchemaPatchesExtension,
-    StrategyDefinition,
-    OpenApiStringFormatsExtension,
     GraphQLScalarsExtension,
     MediaTypesExtension,
+    OpenApiStringFormatsExtension,
+    SchemaPatchesExtension,
+    StrategyDefinition,
     TransformFunctionDefinition,
 )
 

schemathesis/service/hosts.py

@@ -1,6 +1,7 @@
 """Work with stored auth data."""
 
 from __future__ import annotations
+
 import enum
 import tempfile
 from dataclasses import dataclass

schemathesis/service/metadata.py

@@ -1,10 +1,11 @@
 """Useful info to collect from CLI usage."""
 
 from __future__ import annotations
+
 import os
 import platform
-from importlib import metadata
 from dataclasses import dataclass, field
+from importlib import metadata
 
 from ..constants import SCHEMATHESIS_VERSION
 from .constants import DOCKER_IMAGE_ENV_VAR

schemathesis/service/models.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
+
 from dataclasses import dataclass, field
 from enum import Enum
-from typing import Any, Iterable, TypedDict, Union, Literal
+from typing import Any, Iterable, Literal, TypedDict, Union
 
 
 class UploadSource(str, Enum):

schemathesis/service/report.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 import enum
 import json
 import os
@@ -9,7 +10,7 @@ from contextlib import suppress
 from dataclasses import asdict, dataclass, field
 from io import BytesIO
 from queue import Queue
-from typing import Any, TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 import click
 
@@ -22,11 +23,10 @@ from .metadata import Metadata
 from .models import UploadResponse
 from .serialization import serialize_event
 
-
 if TYPE_CHECKING:
-    from .client import ServiceClient
     from ..cli.context import ExecutionContext
     from ..runner.events import ExecutionEvent
+    from .client import ServiceClient
 
 
 @dataclass

schemathesis/service/serialization.py

@@ -7,9 +7,10 @@ from ..exceptions import format_exception
 from ..internal.result import Err, Ok
 from ..internal.transformation import merge_recursively
 from ..models import Response
-from .models import AnalysisSuccess
 from ..runner import events
-from ..runner.serialization import SerializedCase
+from ..runner.serialization import SerializedCase, SerializedCheck
+from ..stateful import events as stateful_events
+from .models import AnalysisSuccess
 
 S = TypeVar("S", bound=events.ExecutionEvent)
 SerializeFunc = Callable[[S], Optional[Dict[str, Any]]]
@@ -81,6 +82,27 @@ def _serialize_response(response: Response) -> dict[str, Any]:
     }
 
 
+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 serialize_after_execution(event: events.AfterExecution) -> dict[str, Any] | None:
     return {
         "correlation_id": event.correlation_id,
@@ -89,27 +111,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,
         },
@@ -147,6 +149,37 @@ 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:
+    data: dict[str, Any]
+    if isinstance(event, stateful_events.RunStarted):
+        data = {
+            "timestamp": event.timestamp,
+            "started_at": event.started_at,
+        }
+    elif isinstance(event, stateful_events.SuiteFinished):
+        data = {
+            "timestamp": event.timestamp,
+            "status": event.status,
+            "failures": [_serialize_check(SerializedCheck.from_check(failure)) for failure in event.failures],
+        }
+    elif isinstance(event, stateful_events.Errored):
+        data = {
+            "timestamp": event.timestamp,
+            "exception": format_exception(event.exception, True),
+        }
+    else:
+        data = asdict(event)
+    return {"data": {event.__class__.__name__: data}}
+
+
+def serialize_after_stateful_execution(event: events.AfterStatefulExecution) -> dict[str, Any] | None:
+    return {"result": asdict(event.result)}
+
+
 SERIALIZER_MAP = {
     events.Initialized: serialize_initialized,
     events.BeforeProbing: serialize_before_probing,
@@ -157,6 +190,8 @@ SERIALIZER_MAP = {
     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,
 }
 
@@ -173,6 +208,8 @@ def serialize_event(
     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]:
@@ -188,6 +225,8 @@ def serialize_event(
         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:

schemathesis/service/usage.py

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

schemathesis/specs/graphql/_cache.py

@@ -4,8 +4,8 @@ from dataclasses import dataclass, field
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from ...schemas import APIOperationMap
     from ...models import APIOperation
+    from ...schemas import APIOperationMap
 
 
 @dataclass

schemathesis/specs/graphql/loaders.py

@@ -16,6 +16,7 @@ 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
@@ -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,
@@ -161,6 +165,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 +203,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 +228,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,8 +241,8 @@ def from_dict(
     :param app: A WSGI app instance.
     :return: GraphQLSchema
     """
-    from .schemas import GraphQLSchema
     from ... import transports
+    from .schemas import GraphQLSchema
 
     _code_sample_style = CodeSampleStyle.from_str(code_sample_style)
     hook_context = HookContext()
@@ -250,6 +258,8 @@ def from_dict(
         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,
@@ -266,6 +276,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,
@@ -294,6 +305,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,
@@ -307,6 +320,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,
@@ -332,6 +346,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,

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__)
 

schemathesis/specs/graphql/schemas.py

@@ -6,16 +6,16 @@ from dataclasses import dataclass, field
 from difflib import get_close_matches
 from enum import unique
 from typing import (
+    TYPE_CHECKING,
     Any,
     Callable,
     Generator,
+    Iterator,
+    Mapping,
+    NoReturn,
     Sequence,
     TypeVar,
     cast,
-    TYPE_CHECKING,
-    NoReturn,
-    Mapping,
-    Iterator,
 )
 from urllib.parse import urlsplit, urlunsplit
 
@@ -25,12 +25,11 @@ from hypothesis.strategies import SearchStrategy
 from hypothesis_graphql import strategies as gql_st
 from requests.structures import CaseInsensitiveDict
 
-from ..openapi.constants import LOCATION_TO_CONTAINER
 from ... import auths
 from ...auths import AuthStorage
 from ...checks import not_a_server_error
 from ...constants import NOT_SET
-from ...exceptions import OperationSchemaError, OperationNotFound
+from ...exceptions import OperationNotFound, OperationSchemaError
 from ...generation import DataGenerationMethod, GenerationConfig
 from ...hooks import (
     GLOBAL_HOOK_DISPATCHER,
@@ -41,9 +40,10 @@ from ...hooks import (
 )
 from ...internal.result import Ok, Result
 from ...models import APIOperation, Case, CheckFunction, OperationDefinition
-from ...schemas import BaseSchema, APIOperationMap
+from ...schemas import APIOperationMap, BaseSchema
 from ...stateful import Stateful, StatefulTest
 from ...types import Body, Cookies, Headers, NotSet, PathParameters, Query
+from ..openapi.constants import LOCATION_TO_CONTAINER
 from ._cache import OperationCache
 from .scalars import CUSTOM_SCALARS, get_extra_scalar_strategies
 

schemathesis/specs/graphql/validation.py

@@ -1,5 +1,4 @@
-from typing import Any, cast, List
-
+from typing import Any, List, cast
 
 from ... import failures
 from ...exceptions import get_grouped_graphql_error, get_unexpected_graphql_response_error

schemathesis/specs/openapi/_hypothesis.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 import string
 import time
 from base64 import b64encode
@@ -9,28 +10,29 @@ from typing import Any, Callable, Dict, Iterable, Optional
 from urllib.parse import quote_plus
 from weakref import WeakKeyDictionary
 
-from hypothesis import strategies as st, reject
+from hypothesis import reject
+from hypothesis import strategies as st
 from hypothesis_jsonschema import from_schema
 from requests.auth import _basic_auth_str
 from requests.structures import CaseInsensitiveDict
 from requests.utils import to_key_val_list
 
+from ... import auths, serializers
 from ..._hypothesis import prepare_urlencoded
 from ...constants import NOT_SET
-from .formats import STRING_FORMATS
-from ... import auths, serializers
+from ...exceptions import BodyInGetRequestError, SerializationNotPossible
 from ...generation import DataGenerationMethod, GenerationConfig
-from ...internal.copy import fast_deepcopy
-from ...exceptions import SerializationNotPossible, BodyInGetRequestError
 from ...hooks import HookContext, HookDispatcher, apply_to_all_dispatchers
+from ...internal.copy import fast_deepcopy
 from ...internal.validation import is_illegal_surrogate
 from ...models import APIOperation, Case, cant_serialize
+from ...serializers import Binary
 from ...transports.content_types import parse_content_type
 from ...transports.headers import has_invalid_characters, is_latin_1_encodable
 from ...types import NotSet
-from ...serializers import Binary
 from ...utils import compose, skip
 from .constants import LOCATION_TO_CONTAINER
+from .formats import STRING_FORMATS
 from .media_types import MEDIA_TYPES
 from .negative import negative_schema
 from .negative.utils import can_negate
@@ -360,11 +362,15 @@ def get_parameters_strategy(
         if operation in _PARAMETER_STRATEGIES_CACHE and nested_cache_key in _PARAMETER_STRATEGIES_CACHE[operation]:
             return _PARAMETER_STRATEGIES_CACHE[operation][nested_cache_key]
         schema = parameters_to_json_schema(operation, parameters)
-        if not operation.schema.validate_schema and location == "path":
-            # If schema validation is disabled, we try to generate data even if the parameter definition
-            # contains errors.
-            # In this case, we know that the `required` keyword should always be `True`.
-            schema["required"] = list(schema["properties"])
+        if location == "path":
+            if not operation.schema.validate_schema:
+                # If schema validation is disabled, we try to generate data even if the parameter definition
+                # contains errors.
+                # In this case, we know that the `required` keyword should always be `True`.
+                schema["required"] = list(schema["properties"])
+            for prop in schema.get("properties", {}).values():
+                if prop.get("type") == "string":
+                    prop.setdefault("minLength", 1)
         schema = operation.schema.prepare_schema(schema)
         for name in exclude:
             # Values from `exclude` are not necessarily valid for the schema - they come from user-defined examples