schemathesis 3.35.4__py3-none-any.whl → 3.36.0__py3-none-any.whl

schemathesis/specs/openapi/schemas.py

@@ -20,21 +20,18 @@ from typing import (
     Mapping,
     NoReturn,
     Sequence,
-    Type,
     TypeVar,
     cast,
 )
 from urllib.parse import urlsplit
 
 import jsonschema
-from hypothesis.strategies import SearchStrategy
 from packaging import version
 from requests.structures import CaseInsensitiveDict
 
 from ... import experimental, failures
 from ..._compat import MultipleFailures
 from ..._override import CaseOverride, check_no_override_mark, set_override_mark
-from ...auths import AuthStorage
 from ...constants import HTTP_METHODS, NOT_SET
 from ...exceptions import (
     InternalError,
@@ -54,10 +51,8 @@ from ...internal.result import Err, Ok, Result
 from ...models import APIOperation, Case, OperationDefinition
 from ...schemas import APIOperationMap, BaseSchema
 from ...stateful import Stateful, StatefulTest
-from ...stateful.state_machine import APIStateMachine
 from ...transports.content_types import is_json_media_type, parse_content_type
 from ...transports.responses import get_json
-from ...types import Body, Cookies, FormData, GenericTest, Headers, NotSet, PathParameters, Query
 from . import links, serialization
 from ._cache import OperationCache
 from ._hypothesis import get_case_strategy
@@ -83,7 +78,12 @@ from .security import BaseSecurityProcessor, OpenAPISecurityProcessor, SwaggerSe
 from .stateful import create_state_machine
 
 if TYPE_CHECKING:
+    from hypothesis.strategies import SearchStrategy
+
+    from ...auths import AuthStorage
+    from ...stateful.state_machine import APIStateMachine
     from ...transports.responses import GenericResponse
+    from ...types import Body, Cookies, FormData, GenericTest, Headers, NotSet, PathParameters, Query
 
 SCHEMA_ERROR_MESSAGE = "Ensure that the definition complies with the OpenAPI specification"
 SCHEMA_PARSING_ERRORS = (KeyError, AttributeError, jsonschema.exceptions.RefResolutionError)
@@ -253,7 +253,7 @@ class BaseOpenAPISchema(BaseSchema):
         return self.collect_parameters(itertools.chain(parameters, shared_parameters), operation)
 
     def get_all_operations(
-        self, hooks: HookDispatcher | None = None
+        self, hooks: HookDispatcher | None = None, generation_config: GenerationConfig | None = None
     ) -> Generator[Result[APIOperation, OperationSchemaError], None, None]:
         """Iterate over all operations defined in the API.
 
@@ -308,7 +308,17 @@ class BaseOpenAPISchema(BaseSchema):
                                 continue
                             parameters = resolved.get("parameters", ())
                             parameters = collect_parameters(itertools.chain(parameters, shared_parameters), resolved)
-                            operation = make_operation(path, method, parameters, entry, resolved, scope)
+                            operation = make_operation(
+                                path,
+                                method,
+                                parameters,
+                                entry,
+                                resolved,
+                                scope,
+                                with_security_parameters=generation_config.with_security_parameters
+                                if generation_config
+                                else None,
+                            )
                             context = HookContext(operation=operation)
                             if (
                                 should_skip_operation(GLOBAL_HOOK_DISPATCHER, context)
@@ -383,6 +393,7 @@ class BaseOpenAPISchema(BaseSchema):
         raw: dict[str, Any],
         resolved: dict[str, Any],
         scope: str,
+        with_security_parameters: bool | None = None,
     ) -> APIOperation:
         """Create JSON schemas for the query, body, etc from Swagger parameters definitions."""
         __tracebackhide__ = True
@@ -397,7 +408,12 @@ class BaseOpenAPISchema(BaseSchema):
         )
         for parameter in parameters:
             operation.add_parameter(parameter)
-        if self.generation_config.with_security_parameters:
+        with_security_parameters = (
+            with_security_parameters
+            if with_security_parameters is not None
+            else self.generation_config.with_security_parameters
+        )
+        if with_security_parameters:
             self.security.process_definitions(self.raw_schema, operation, self.resolver)
         self.dispatch_hook("before_init_operation", HookContext(operation=operation), operation)
         return operation
@@ -626,7 +642,7 @@ class BaseOpenAPISchema(BaseSchema):
         return operation.definition.raw.get("tags")
 
     @property
-    def validator_cls(self) -> Type[jsonschema.Validator]:
+    def validator_cls(self) -> type[jsonschema.Validator]:
         if self.spec_version.startswith("3.1") and experimental.OPEN_API_3_1.is_enabled:
             return jsonschema.Draft202012Validator
         return jsonschema.Draft4Validator
@@ -791,11 +807,10 @@ class BaseOpenAPISchema(BaseSchema):
 
 def _maybe_raise_one_or_more(errors: list[Exception]) -> None:
     if not errors:
-        return None
-    elif len(errors) == 1:
+        return
+    if len(errors) == 1:
         raise errors[0]
-    else:
-        raise MultipleFailures("\n\n".join(str(error) for error in errors), errors)
+    raise MultipleFailures("\n\n".join(str(error) for error in errors), errors)
 
 
 def _make_reference_key(scopes: list[str], reference: str) -> str:

schemathesis/specs/openapi/security.py

@@ -3,13 +3,15 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Any, ClassVar, Generator
+from typing import TYPE_CHECKING, Any, ClassVar, Generator
 
-from jsonschema import RefResolver
-
-from ...models import APIOperation
 from .parameters import OpenAPI20Parameter, OpenAPI30Parameter, OpenAPIParameter
 
+if TYPE_CHECKING:
+    from jsonschema import RefResolver
+
+    from ...models import APIOperation
+
 
 @dataclass
 class BaseSecurityProcessor:

schemathesis/specs/openapi/stateful/__init__.py

@@ -16,11 +16,11 @@ from .. import expressions
 from ..links import get_all_links
 from ..utils import expand_status_code
 from .statistic import OpenAPILinkStats
-from .types import FilterFunction, LinkName, StatusCode, TargetName
 
 if TYPE_CHECKING:
     from ....models import Case
     from ..schemas import BaseOpenAPISchema
+    from .types import FilterFunction, LinkName, StatusCode, TargetName
 
 
 class OpenAPIStateMachine(APIStateMachine):
@@ -193,7 +193,7 @@ def make_response_matcher(matchers: list[tuple[str, FilterFunction]]) -> Callabl
     return compare
 
 
-@lru_cache()
+@lru_cache
 def make_response_filter(status_code: str, all_status_codes: Iterator[str]) -> FilterFunction:
     """Create a filter for stored responses.
 

schemathesis/specs/openapi/stateful/statistic.py

@@ -1,14 +1,14 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Iterator, List, Union
+from typing import TYPE_CHECKING, Iterator, Union
 
 from ....internal.copy import fast_deepcopy
 from ....stateful.statistic import TransitionStats
-from .types import AggregatedResponseCounter, LinkName, ResponseCounter, SourceName, StatusCode, TargetName
 
 if TYPE_CHECKING:
     from ....stateful import events
+    from .types import AggregatedResponseCounter, LinkName, ResponseCounter, SourceName, StatusCode, TargetName
 
 
 @dataclass
@@ -136,7 +136,7 @@ class OpenAPILinkStats(TransitionStats):
     def to_formatted_table(self, width: int) -> str:
         """Format the statistic as a table."""
         entries = list(self.iter_with_format())
-        lines: List[str | list[str]] = [HEADER, ""]
+        lines: list[str | list[str]] = [HEADER, ""]
         column_widths = [len(column) for column in HEADER]
         for entry in entries:
             if isinstance(entry.entry, Link):

schemathesis/specs/openapi/stateful/types.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
 
-from typing import Callable, Dict, TypedDict, Union
+from typing import TYPE_CHECKING, Callable, Dict, TypedDict, Union
 
-from ....stateful.state_machine import StepResult
+if TYPE_CHECKING:
+    from ....stateful.state_machine import StepResult
 
 StatusCode = str
 LinkName = str

schemathesis/stateful/__init__.py

@@ -5,15 +5,15 @@ import json
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any, Callable, Generator
 
-from .. import GenerationConfig
 from ..constants import NOT_SET
-from ..exceptions import OperationSchemaError
 from ..internal.result import Ok, Result
-from ..models import APIOperation, Case
 
 if TYPE_CHECKING:
     import hypothesis
 
+    from .. import GenerationConfig
+    from ..exceptions import OperationSchemaError
+    from ..models import APIOperation, Case
     from ..transports.responses import GenericResponse
     from .state_machine import APIStateMachine
 

schemathesis/stateful/config.py

@@ -21,7 +21,7 @@ def _default_checks_factory() -> tuple[CheckFunction, ...]:
     from ..checks import ALL_CHECKS
     from ..specs.openapi.checks import ensure_resource_availability, use_after_free
 
-    return ALL_CHECKS + (use_after_free, ensure_resource_availability)
+    return (*ALL_CHECKS, use_after_free, ensure_resource_availability)
 
 
 def _get_default_hypothesis_settings_kwargs() -> dict[str, Any]:
@@ -69,6 +69,7 @@ class StatefulTestRunnerConfig:
     max_response_time: int | None = None
     dry_run: bool = False
     targets: list[Target] = field(default_factory=list)
+    unique_data: bool = False
 
     def __post_init__(self) -> None:
         import hypothesis

schemathesis/stateful/context.py

@@ -4,6 +4,7 @@ import traceback
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Tuple, Type, Union
 
+from ..constants import NOT_SET
 from ..exceptions import CheckFailed
 from ..targets import TargetMetricCollector
 from . import events
@@ -11,6 +12,7 @@ from . import events
 if TYPE_CHECKING:
     from ..models import Case, Check
     from ..transports.responses import GenericResponse
+    from ..types import NotSet
 
 FailureKey = Union[Type[CheckFailed], Tuple[str, int]]
 
@@ -52,16 +54,17 @@ class RunnerContext:
     completed_scenarios: int = 0
     # Metrics collector for targeted testing
     metric_collector: TargetMetricCollector = field(default_factory=lambda: TargetMetricCollector(targets=[]))
+    step_outcomes: dict[int, BaseException | None] = field(default_factory=dict)
 
     @property
     def current_scenario_status(self) -> events.ScenarioStatus:
         if self.current_step_status == events.StepStatus.SUCCESS:
             return events.ScenarioStatus.SUCCESS
-        elif self.current_step_status == events.StepStatus.FAILURE:
+        if self.current_step_status == events.StepStatus.FAILURE:
             return events.ScenarioStatus.FAILURE
-        elif self.current_step_status == events.StepStatus.ERROR:
+        if self.current_step_status == events.StepStatus.ERROR:
             return events.ScenarioStatus.ERROR
-        elif self.current_step_status == events.StepStatus.INTERRUPTED:
+        if self.current_step_status == events.StepStatus.INTERRUPTED:
             return events.ScenarioStatus.INTERRUPTED
         return events.ScenarioStatus.REJECTED
 
@@ -69,6 +72,7 @@ class RunnerContext:
         self.completed_scenarios += 1
         self.current_step_status = None
         self.current_response = None
+        self.step_outcomes.clear()
 
     def reset_step(self) -> None:
         self.checks_for_step = []
@@ -123,3 +127,9 @@ class RunnerContext:
         self.seen_in_suite.clear()
         self.reset_scenario()
         self.metric_collector.reset()
+
+    def store_step_outcome(self, case: Case, outcome: BaseException | None) -> None:
+        self.step_outcomes[hash(case)] = outcome
+
+    def get_step_outcome(self, case: Case) -> BaseException | None | NotSet:
+        return self.step_outcomes.get(hash(case), NOT_SET)

schemathesis/stateful/events.py

@@ -4,7 +4,7 @@ import time
 from dataclasses import asdict as _asdict
 from dataclasses import dataclass
 from enum import Enum
-from typing import TYPE_CHECKING, Any, Type
+from typing import TYPE_CHECKING, Any
 
 from ..exceptions import format_exception
 
@@ -40,11 +40,11 @@ class RunStarted(StatefulEvent):
     """Before executing all scenarios."""
 
     started_at: float
-    state_machine: Type[APIStateMachine]
+    state_machine: type[APIStateMachine]
 
     __slots__ = ("state_machine", "timestamp", "started_at")
 
-    def __init__(self, *, state_machine: Type[APIStateMachine]) -> None:
+    def __init__(self, *, state_machine: type[APIStateMachine]) -> None:
         self.state_machine = state_machine
         self.started_at = time.time()
         self.timestamp = time.monotonic()

schemathesis/stateful/runner.py

@@ -4,13 +4,12 @@ import queue
 import threading
 from contextlib import contextmanager
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any, Generator, Iterator, Type
+from typing import TYPE_CHECKING, Any, Generator, Iterator
 
 import hypothesis
 import requests
 from hypothesis.control import current_build_context
 from hypothesis.errors import Flaky, Unsatisfiable
-from hypothesis.stateful import Rule
 
 from ..exceptions import CheckFailed
 from ..targets import TargetMetricCollector
@@ -20,6 +19,8 @@ from .context import RunnerContext
 from .validation import validate_response
 
 if TYPE_CHECKING:
+    from hypothesis.stateful import Rule
+
     from ..models import Case, CheckFunction
     from ..transports.responses import GenericResponse
     from .state_machine import APIStateMachine, Direction, StepResult
@@ -36,7 +37,7 @@ class StatefulTestRunner:
     """
 
     # State machine class to use
-    state_machine: Type[APIStateMachine]
+    state_machine: type[APIStateMachine]
     # Test runner configuration that defines the runtime behavior
     config: StatefulTestRunnerConfig = field(default_factory=StatefulTestRunnerConfig)
     # Event to stop the execution
@@ -105,7 +106,7 @@ def thread_manager(thread: threading.Thread) -> Generator[None, None, None]:
 
 def _execute_state_machine_loop(
     *,
-    state_machine: Type[APIStateMachine],
+    state_machine: type[APIStateMachine],
     event_queue: queue.Queue,
     config: StatefulTestRunnerConfig,
     stop_event: threading.Event,
@@ -162,17 +163,34 @@ def _execute_state_machine_loop(
             try:
                 if config.dry_run:
                     return None
+                if config.unique_data:
+                    cached = ctx.get_step_outcome(case)
+                    if isinstance(cached, BaseException):
+                        raise cached
+                    elif cached is None:
+                        return None
                 result = super().step(case, previous)
                 ctx.step_succeeded()
-            except CheckFailed:
+            except CheckFailed as exc:
+                if config.unique_data:
+                    ctx.store_step_outcome(case, exc)
                 ctx.step_failed()
                 raise
-            except Exception:
+            except Exception as exc:
+                if config.unique_data:
+                    ctx.store_step_outcome(case, exc)
                 ctx.step_errored()
                 raise
             except KeyboardInterrupt:
                 ctx.step_interrupted()
                 raise
+            except BaseException as exc:
+                if config.unique_data:
+                    ctx.store_step_outcome(case, exc)
+                raise exc
+            else:
+                if config.unique_data:
+                    ctx.store_step_outcome(case, None)
             finally:
                 transition_id: events.TransitionId | None
                 if previous is not None:

schemathesis/stateful/sink.py

@@ -4,10 +4,10 @@ from dataclasses import dataclass, field
 from typing import TYPE_CHECKING
 
 from . import events
-from .statistic import TransitionStats
 
 if TYPE_CHECKING:
     from ..models import Check
+    from .statistic import TransitionStats
 
 
 @dataclass

schemathesis/stateful/state_machine.py

@@ -4,7 +4,7 @@ import re
 import time
 from dataclasses import dataclass
 from functools import lru_cache
-from typing import TYPE_CHECKING, Any, ClassVar, Type
+from typing import TYPE_CHECKING, Any, ClassVar
 
 from hypothesis.errors import InvalidDefinition
 from hypothesis.stateful import RuleBasedStateMachine
@@ -12,11 +12,11 @@ from hypothesis.stateful import RuleBasedStateMachine
 from .._dependency_versions import HYPOTHESIS_HAS_STATEFUL_NAMING_IMPROVEMENTS
 from ..constants import NO_LINKS_ERROR_MESSAGE, NOT_SET
 from ..exceptions import UsageError
-from ..models import APIOperation, Case, CheckFunction
+from ..internal.checks import CheckFunction
+from ..models import APIOperation, Case
 from .config import _default_hypothesis_settings_factory
 from .runner import StatefulTestRunner, StatefulTestRunnerConfig
 from .sink import StateMachineSink
-from .statistic import TransitionStats
 
 if TYPE_CHECKING:
     import hypothesis
@@ -24,6 +24,7 @@ if TYPE_CHECKING:
 
     from ..schemas import BaseSchema
     from ..transports.responses import GenericResponse
+    from .statistic import TransitionStats
 
 
 @dataclass
@@ -64,7 +65,7 @@ class APIStateMachine(RuleBasedStateMachine):
 
     @classmethod
     @lru_cache
-    def _to_test_case(cls) -> Type:
+    def _to_test_case(cls) -> type:
         from . import run_state_machine_as_test
 
         class StateMachineTestCase(RuleBasedStateMachine.TestCase):
@@ -97,7 +98,7 @@ class APIStateMachine(RuleBasedStateMachine):
 
     def _add_result_to_targets(self, targets: tuple[str, ...], result: StepResult | None) -> None:
         if result is None:
-            return None
+            return
         target = self._get_target_for_result(result)
         if target is not None:
             super()._add_result_to_targets((target,), result)
@@ -310,7 +311,7 @@ def _print_case(case: Case, kwargs: dict[str, Any]) -> str:
     headers.update(kwargs.get("headers", {}))
     case.headers = headers
     data = [
-        f"{name}={repr(getattr(case, name))}"
+        f"{name}={getattr(case, name)!r}"
         for name in ("path_parameters", "headers", "cookies", "query", "body", "media_type")
         if getattr(case, name) not in (None, NOT_SET)
     ]

schemathesis/stateful/statistic.py

@@ -1,8 +1,10 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
+from typing import TYPE_CHECKING
 
-from . import events
+if TYPE_CHECKING:
+    from . import events
 
 
 @dataclass

schemathesis/stateful/validation.py

@@ -1,14 +1,16 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 from ..exceptions import CheckFailed, get_grouped_exception
-from .context import RunnerContext
+from ..internal.checks import CheckContext
 
 if TYPE_CHECKING:
     from ..failures import FailureContext
-    from ..models import Case, CheckFunction
+    from ..internal.checks import CheckFunction
+    from ..models import Case
     from ..transports.responses import GenericResponse
+    from .context import RunnerContext
 
 
 def validate_response(
@@ -19,8 +21,11 @@ def validate_response(
     checks: tuple[CheckFunction, ...],
     additional_checks: tuple[CheckFunction, ...] = (),
     max_response_time: int | None = None,
+    headers: dict[str, Any] | None = None,
 ) -> None:
     """Validate the response against the provided checks."""
+    from requests.structures import CaseInsensitiveDict
+
     from .._compat import MultipleFailures
     from ..checks import _make_max_response_time_failure_message
     from ..failures import ResponseTimeExceeded
@@ -28,6 +33,7 @@ def validate_response(
 
     exceptions: list[CheckFailed | AssertionError] = []
     check_results = ctx.checks_for_step
+    check_ctx = CheckContext(headers=CaseInsensitiveDict(headers) if headers else None)
 
     def _on_failure(exc: CheckFailed | AssertionError, message: str, context: FailureContext | None) -> None:
         exceptions.append(exc)
@@ -62,8 +68,7 @@ def validate_response(
         name = check.__name__
         copied_case = case.partial_deepcopy()
         try:
-            check(response, copied_case)
-            skip_check = check(response, copied_case)
+            skip_check = check(check_ctx, response, copied_case)
             if not skip_check:
                 _on_passed(name, copied_case)
         except CheckFailed as exc:

schemathesis/transports/__init__.py

@@ -101,7 +101,7 @@ class RequestsTransport:
         cookies: dict[str, Any] | None = None,
     ) -> dict[str, Any]:
         final_headers = case._get_headers(headers)
-        media_type: Optional[str]
+        media_type: str | None
         if case.body is not NOT_SET and case.media_type is None:
             media_type = case.operation._get_default_media_type()
         else:
@@ -274,7 +274,7 @@ class WSGITransport:
         cookies: dict[str, Any] | None = None,
     ) -> dict[str, Any]:
         final_headers = case._get_headers(headers)
-        media_type: Optional[str]
+        media_type: str | None
         if case.body is not NOT_SET and case.media_type is None:
             media_type = case.operation._get_default_media_type()
         else:

schemathesis/transports/asgi.py

@@ -0,0 +1,7 @@
+from inspect import iscoroutinefunction
+
+
+def is_asgi_app(app: object) -> bool:
+    return iscoroutinefunction(app) or (
+        hasattr(app, "__call__") and iscoroutinefunction(app.__call__)  # noqa: B004
+    )

schemathesis/transports/auth.py

@@ -3,11 +3,12 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Any
 
 from ..constants import USER_AGENT
-from ..types import RawAuth
 
 if TYPE_CHECKING:
     from requests.auth import HTTPDigestAuth
 
+    from ..types import RawAuth
+
 
 def get_requests_auth(auth: RawAuth | None, auth_type: str | None) -> HTTPDigestAuth | RawAuth | None:
     from requests.auth import HTTPDigestAuth

schemathesis/transports/content_types.py

@@ -31,7 +31,7 @@ def parse_header(line: str) -> Tuple[str, dict]:
     return key, pdict
 
 
-@lru_cache()
+@lru_cache
 def parse_content_type(content_type: str) -> Tuple[str, str]:
     """Parse Content Type and return main type and subtype."""
     try:

schemathesis/transports/responses.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import json
 import sys
-from datetime import timedelta
 from typing import TYPE_CHECKING, Any, NoReturn, Union
 
 from werkzeug.wrappers import Response as BaseResponse
@@ -10,6 +9,8 @@ from werkzeug.wrappers import Response as BaseResponse
 from .._compat import JSONMixin
 
 if TYPE_CHECKING:
+    from datetime import timedelta
+
     from httpx import Response as httpxResponse
     from requests import PreparedRequest
     from requests import Response as requestsResponse

schemathesis/utils.py

@@ -5,6 +5,7 @@ from contextlib import contextmanager
 from inspect import getfullargspec
 from pathlib import Path
 from typing import (
+    TYPE_CHECKING,
     Any,
     Callable,
     Generator,
@@ -20,9 +21,10 @@ from hypothesis.strategies import SearchStrategy
 from ._compat import InferType, get_signature
 
 # Backward-compat
-from .constants import NOT_SET  # noqa: F401
 from .exceptions import SkipTest, UsageError
-from .types import GenericTest, PathLike
+
+if TYPE_CHECKING:
+    from .types import GenericTest, PathLike
 
 
 def is_schemathesis_test(func: Callable) -> bool:

{schemathesis-3.35.4.dist-info → schemathesis-3.36.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: schemathesis
-Version: 3.35.4
+Version: 3.36.0
 Summary: Property-based testing framework for Open API and GraphQL based apps
 Project-URL: Documentation, https://schemathesis.readthedocs.io/en/stable/
 Project-URL: Changelog, https://schemathesis.readthedocs.io/en/stable/changelog.html