schemathesis 3.29.1__py3-none-any.whl → 3.30.0__py3-none-any.whl

schemathesis/runner/impl/core.py

@@ -21,9 +21,7 @@ from jsonschema.exceptions import SchemaError as JsonSchemaError
 from jsonschema.exceptions import ValidationError
 from requests.auth import HTTPDigestAuth, _basic_auth_str
 
-from schemathesis.transports import RequestsTransport
-
-from ... import failures, hooks
+from ... import experimental, failures, hooks
 from ..._compat import MultipleFailures
 from ..._hypothesis import (
     get_invalid_example_headers_mark,
@@ -65,7 +63,10 @@ from ...service import extensions
 from ...service.models import AnalysisResult, AnalysisSuccess
 from ...specs.openapi import formats
 from ...stateful import Feedback, Stateful
+from ...stateful import events as stateful_events
+from ...stateful import runner as stateful_runner
 from ...targets import Target, TargetContext
+from ...transports import RequestsTransport, prepare_timeout
 from ...types import RawAuth, RequestCert
 from ...utils import capture_hypothesis_output
 from .. import probes
@@ -191,7 +192,9 @@ class BaseRunner:
                 return
 
         try:
-            yield from self._execute(results, stop_event)
+            if not experimental.STATEFUL_ONLY.is_enabled:
+                yield from self._execute(results, stop_event)
+            yield from self._run_stateful_tests(results)
         except KeyboardInterrupt:
             yield events.Interrupted()
 
@@ -211,6 +214,32 @@ class BaseRunner:
     ) -> Generator[events.ExecutionEvent, None, None]:
         raise NotImplementedError
 
+    def _run_stateful_tests(self, results: TestResultSet) -> Generator[events.ExecutionEvent, None, None]:
+        # Run new-style stateful tests
+        if self.stateful is not None and experimental.STATEFUL_TEST_RUNNER.is_enabled:
+            result = TestResult(
+                method="",
+                path="",
+                verbose_name="Stateful tests",
+                data_generation_method=self.schema.data_generation_methods,
+            )
+            config = stateful_runner.StatefulTestRunnerConfig(
+                checks=tuple(self.checks),
+                headers=self.headers or {},
+                hypothesis_settings=self.hypothesis_settings,
+                exit_first=self.exit_first,
+                request_timeout=self.request_timeout,
+            )
+            state_machine = self.schema.as_state_machine()
+            runner = state_machine.runner(config=config)
+            for stateful_event in runner.execute():
+                if isinstance(stateful_event, stateful_events.SuiteFinished):
+                    for failure in stateful_event.failures:
+                        result.checks.append(failure)
+                yield events.StatefulEvent(data=stateful_event)
+            results.append(result)
+            yield events.AfterStatefulExecution(result=SerializedTestResult.from_test_result(result))
+
     def _run_tests(
         self,
         maker: Callable,
@@ -246,7 +275,10 @@ class BaseRunner:
         ):
             if isinstance(result, Ok):
                 operation, test = result.ok()
-                feedback = Feedback(self.stateful, operation)
+                if self.stateful is not None and not experimental.STATEFUL_TEST_RUNNER.is_enabled:
+                    feedback = Feedback(self.stateful, operation)
+                else:
+                    feedback = None
                 # Track whether `BeforeExecution` was already emitted.
                 # Schema error may happen before / after `BeforeExecution`, but it should be emitted only once
                 # and the `AfterExecution` event should have the same correlation id as previous `BeforeExecution`
@@ -268,17 +300,18 @@ class BaseRunner:
                         if isinstance(event, events.Interrupted):
                             return
                     # Additional tests, generated via the `feedback` instance
-                    yield from self._run_tests(
-                        feedback.get_stateful_tests,
-                        template,
-                        settings=settings,
-                        generation_config=generation_config,
-                        seed=seed,
-                        recursion_level=recursion_level + 1,
-                        results=results,
-                        headers=headers,
-                        **kwargs,
-                    )
+                    if feedback is not None:
+                        yield from self._run_tests(
+                            feedback.get_stateful_tests,
+                            template,
+                            settings=settings,
+                            generation_config=generation_config,
+                            seed=seed,
+                            recursion_level=recursion_level + 1,
+                            results=results,
+                            headers=headers,
+                            **kwargs,
+                        )
                 except OperationSchemaError as exc:
                     yield from handle_schema_error(
                         exc,
@@ -788,7 +821,7 @@ def network_test(
     request_cert: RequestCert | None,
     store_interactions: bool,
     headers: dict[str, Any] | None,
-    feedback: Feedback,
+    feedback: Feedback | None,
     max_response_time: int | None,
     data_generation_methods: list[DataGenerationMethod],
     dry_run: bool,
@@ -830,7 +863,7 @@ def _network_test(
     timeout: float | None,
     store_interactions: bool,
     headers: dict[str, Any] | None,
-    feedback: Feedback,
+    feedback: Feedback | None,
     request_tls_verify: bool,
     request_proxy: str | None,
     request_cert: RequestCert | None,
@@ -877,7 +910,8 @@ def _network_test(
         status = Status.failure
         raise
     finally:
-        feedback.add_test_case(case, response)
+        if feedback is not None:
+            feedback.add_test_case(case, response)
         if store_interactions:
             result.store_requests_response(case, response, status, check_results)
     return response
@@ -891,14 +925,6 @@ def get_session(auth: HTTPDigestAuth | RawAuth | None = None) -> Generator[reque
         yield session
 
 
-def prepare_timeout(timeout: int | None) -> float | None:
-    """Request timeout is in milliseconds, but `requests` uses seconds."""
-    output: int | float | None = timeout
-    if timeout is not None:
-        output = timeout / 1000
-    return output
-
-
 def wsgi_test(
     case: Case,
     checks: Iterable[CheckFunction],
@@ -908,7 +934,7 @@ def wsgi_test(
     auth_type: str | None,
     headers: dict[str, Any] | None,
     store_interactions: bool,
-    feedback: Feedback,
+    feedback: Feedback | None,
     max_response_time: int | None,
     data_generation_methods: list[DataGenerationMethod],
     dry_run: bool,
@@ -939,7 +965,7 @@ def _wsgi_test(
     result: TestResult,
     headers: dict[str, Any],
     store_interactions: bool,
-    feedback: Feedback,
+    feedback: Feedback | None,
     max_response_time: int | None,
 ) -> WSGIResponse:
     from ...transports.responses import WSGIResponse
@@ -968,7 +994,8 @@ def _wsgi_test(
         status = Status.failure
         raise
     finally:
-        feedback.add_test_case(case, response)
+        if feedback is not None:
+            feedback.add_test_case(case, response)
         if store_interactions:
             result.store_wsgi_response(case, response, headers, response.elapsed.total_seconds(), status, check_results)
     return response
@@ -1001,7 +1028,7 @@ def asgi_test(
     result: TestResult,
     store_interactions: bool,
     headers: dict[str, Any] | None,
-    feedback: Feedback,
+    feedback: Feedback | None,
     max_response_time: int | None,
     data_generation_methods: list[DataGenerationMethod],
     dry_run: bool,
@@ -1034,7 +1061,7 @@ def _asgi_test(
     result: TestResult,
     store_interactions: bool,
     headers: dict[str, Any] | None,
-    feedback: Feedback,
+    feedback: Feedback | None,
     max_response_time: int | None,
 ) -> requests.Response:
     hook_context = HookContext(operation=case.operation)
@@ -1059,7 +1086,8 @@ def _asgi_test(
         status = Status.failure
         raise
     finally:
-        feedback.add_test_case(case, response)
+        if feedback is not None:
+            feedback.add_test_case(case, response)
         if store_interactions:
             result.store_requests_response(case, response, status, check_results)
     return response

schemathesis/runner/impl/solo.py

@@ -1,11 +1,12 @@
 from __future__ import annotations
+
 import threading
 from dataclasses import dataclass
 from typing import Generator
 
 from ...models import TestResultSet
-from ...types import RequestCert
 from ...transports.auth import get_requests_auth
+from ...types import RequestCert
 from .. import events
 from .core import BaseRunner, asgi_test, get_session, network_test, wsgi_test
 

schemathesis/runner/impl/threadpool.py

@@ -1,13 +1,16 @@
 from __future__ import annotations
+
 import ctypes
 import queue
 import threading
 import time
+import warnings
 from dataclasses import dataclass
 from queue import Queue
 from typing import Any, Callable, Generator, Iterable, cast
 
 import hypothesis
+from hypothesis.errors import HypothesisWarning
 
 from ..._hypothesis import create_test
 from ...generation import DataGenerationMethod, GenerationConfig
@@ -39,6 +42,7 @@ def _run_task(
     headers: dict[str, Any] | None = None,
     **kwargs: Any,
 ) -> None:
+    warnings.filterwarnings("ignore", message="The recursion limit will not be reset", category=HypothesisWarning)
     as_strategy_kwargs = {}
     if headers is not None:
         as_strategy_kwargs["headers"] = {key: value for key, value in headers.items() if key.lower() != "user-agent"}

schemathesis/runner/probes.py

@@ -22,8 +22,8 @@ from ..transports.auth import get_requests_auth
 if TYPE_CHECKING:
     import requests
 
-    from ..types import RequestCert
     from ..schemas import BaseSchema
+    from ..types import RequestCert
 
 
 HEADER_NAME = "X-Schemathesis-Probe"

schemathesis/runner/serialization.py

@@ -28,7 +28,7 @@ from ..exceptions import (
     make_unique_by_key,
 )
 from ..models import Case, Check, Interaction, Request, Response, Status, TestResult
-from ..transports import serialize_payload, deserialize_payload
+from ..transports import deserialize_payload, serialize_payload
 
 if TYPE_CHECKING:
     import hypothesis.errors

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

schemathesis/schemas.py

@@ -397,10 +397,7 @@ class BaseSchema(Mapping):
         raise NotImplementedError
 
     def as_state_machine(self) -> type[APIStateMachine]:
-        """Create a state machine class.
-
-        Use it for stateful testing.
-        """
+        """Create a state machine class."""
         raise NotImplementedError
 
     def get_links(self, operation: APIOperation) -> dict[str, dict[str, Any]]:

schemathesis/service/ci.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 import enum
 import os
 from dataclasses import asdict, dataclass

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,29 @@ def serialize_finished(event: events.Finished) -> dict[str, Any] | None:
     }
 
 
+def serialize_stateful_event(event: events.StatefulEvent) -> dict[str, Any] | None:
+    if isinstance(event.data, stateful_events.RunStarted):
+        return {
+            "data": {
+                "timestamp": event.data.timestamp,
+                "started_at": event.data.started_at,
+            }
+        }
+    elif isinstance(event.data, stateful_events.SuiteFinished):
+        return {
+            "data": {
+                "timestamp": event.data.timestamp,
+                "status": event.data.status,
+                "failures": [_serialize_check(SerializedCheck.from_check(failure)) for failure in event.data.failures],
+            }
+        }
+    return {"data": asdict(event.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 +182,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 +200,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 +217,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

@@ -233,8 +233,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()

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