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

schemathesis/models.py

@@ -9,7 +9,6 @@ from dataclasses import dataclass, field
 from enum import Enum
 from functools import lru_cache, partial
 from itertools import chain
-from logging import LogRecord
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -18,7 +17,6 @@ from typing import (
     Generic,
     Iterator,
     NoReturn,
-    Optional,
     Sequence,
     Type,
     TypeVar,
@@ -28,7 +26,6 @@ from urllib.parse import quote, unquote, urljoin, urlsplit, urlunsplit
 
 from . import serializers
 from ._dependency_versions import IS_WERKZEUG_ABOVE_3
-from .auths import AuthStorage
 from .code_samples import CodeSampleStyle
 from .constants import (
     NOT_SET,
@@ -38,7 +35,6 @@ from .constants import (
 )
 from .exceptions import (
     CheckFailed,
-    FailureContext,
     OperationSchemaError,
     SerializationNotPossible,
     SkipTest,
@@ -49,24 +45,29 @@ from .exceptions import (
 )
 from .generation import DataGenerationMethod, GenerationConfig, generate_random_case_id
 from .hooks import GLOBAL_HOOK_DISPATCHER, HookContext, HookDispatcher, dispatch
+from .internal.checks import CheckContext
 from .internal.copy import fast_deepcopy
 from .internal.deprecation import deprecated_function, deprecated_property
 from .internal.output import prepare_response_payload
 from .parameters import Parameter, ParameterSet, PayloadAlternatives
 from .sanitization import sanitize_request, sanitize_response
-from .serializers import Serializer
 from .transports import ASGITransport, RequestsTransport, WSGITransport, deserialize_payload, serialize_payload
 from .types import Body, Cookies, FormData, Headers, NotSet, PathParameters, Query
 
 if TYPE_CHECKING:
     import unittest
+    from logging import LogRecord
 
     import requests.auth
     import werkzeug
     from hypothesis import strategies as st
     from requests.structures import CaseInsensitiveDict
 
+    from .auths import AuthStorage
+    from .failures import FailureContext
+    from .internal.checks import CheckFunction
     from .schemas import BaseSchema
+    from .serializers import Serializer
     from .stateful import Stateful, StatefulTest
     from .transports.responses import GenericResponse, WSGIResponse
 
@@ -421,6 +422,7 @@ class Case:
         additional_checks: tuple[CheckFunction, ...] = (),
         excluded_checks: tuple[CheckFunction, ...] = (),
         code_sample_style: str | None = None,
+        headers: dict[str, Any] | None = None,
     ) -> None:
         """Validate application response.
 
@@ -434,17 +436,30 @@ class Case:
         :param code_sample_style: Controls the style of code samples for failure reproduction.
         """
         __tracebackhide__ = True
+        from requests.structures import CaseInsensitiveDict
+
         from .checks import ALL_CHECKS
+        from .internal.checks import wrap_check
         from .transports.responses import get_payload, get_reason
 
-        checks = checks or ALL_CHECKS
+        if checks:
+            _checks = tuple(wrap_check(check) for check in checks)
+        else:
+            _checks = checks
+        if additional_checks:
+            _additional_checks = tuple(wrap_check(check) for check in additional_checks)
+        else:
+            _additional_checks = additional_checks
+
+        checks = _checks or ALL_CHECKS
         checks = tuple(check for check in checks if check not in excluded_checks)
-        additional_checks = tuple(check for check in additional_checks if check not in excluded_checks)
+        additional_checks = tuple(check for check in _additional_checks if check not in excluded_checks)
         failed_checks = []
+        ctx = CheckContext(headers=CaseInsensitiveDict(headers) if headers else None)
         for check in chain(checks, additional_checks):
             copied_case = self.partial_deepcopy()
             try:
-                check(response, copied_case)
+                check(ctx, response, copied_case)
             except AssertionError as exc:
                 maybe_set_assertion_message(exc, check.__name__)
                 failed_checks.append(exc)
@@ -514,7 +529,7 @@ class Case:
     ) -> requests.Response:
         __tracebackhide__ = True
         response = self.call(base_url, session, headers, **kwargs)
-        self.validate_response(response, checks, code_sample_style=code_sample_style)
+        self.validate_response(response, checks, code_sample_style=code_sample_style, headers=headers)
         return response
 
     def _get_url(self, base_url: str | None) -> str:
@@ -995,7 +1010,7 @@ class Interaction:
     """A single interaction with the target app."""
 
     request: Request
-    response: Response
+    response: Response | None
     checks: list[Check]
     status: Status
     data_generation_method: DataGenerationMethod
@@ -1003,10 +1018,28 @@ class Interaction:
     recorded_at: str = field(default_factory=lambda: datetime.datetime.now(TIMEZONE).isoformat())
 
     @classmethod
-    def from_requests(cls, case: Case, response: requests.Response, status: Status, checks: list[Check]) -> Interaction:
+    def from_requests(
+        cls,
+        case: Case,
+        response: requests.Response | None,
+        status: Status,
+        checks: list[Check],
+        headers: dict[str, Any] | None,
+        session: requests.Session | None,
+    ) -> Interaction:
+        if response is not None:
+            prepared = response.request
+            request = Request.from_prepared_request(prepared)
+        else:
+            import requests
+
+            if session is None:
+                session = requests.Session()
+                session.headers.update(headers or {})
+            request = Request.from_case(case, session)
         return cls(
-            request=Request.from_prepared_request(response.request),
-            response=Response.from_requests(response),
+            request=request,
+            response=Response.from_requests(response) if response is not None else None,
             status=status,
             checks=checks,
             data_generation_method=cast(DataGenerationMethod, case.data_generation_method),
@@ -1017,9 +1050,9 @@ class Interaction:
     def from_wsgi(
         cls,
         case: Case,
-        response: WSGIResponse,
+        response: WSGIResponse | None,
         headers: dict[str, Any],
-        elapsed: float,
+        elapsed: float | None,
         status: Status,
         checks: list[Check],
     ) -> Interaction:
@@ -1029,7 +1062,7 @@ class Interaction:
         session.headers.update(headers)
         return cls(
             request=Request.from_case(case, session),
-            response=Response.from_wsgi(response, elapsed),
+            response=Response.from_wsgi(response, elapsed) if response is not None and elapsed is not None else None,
             status=status,
             checks=checks,
             data_generation_method=cast(DataGenerationMethod, case.data_generation_method),
@@ -1119,16 +1152,22 @@ class TestResult:
         self.errors.append(exception)
 
     def store_requests_response(
-        self, case: Case, response: requests.Response, status: Status, checks: list[Check]
+        self,
+        case: Case,
+        response: requests.Response | None,
+        status: Status,
+        checks: list[Check],
+        headers: dict[str, Any] | None,
+        session: requests.Session | None,
     ) -> None:
-        self.interactions.append(Interaction.from_requests(case, response, status, checks))
+        self.interactions.append(Interaction.from_requests(case, response, status, checks, headers, session))
 
     def store_wsgi_response(
         self,
         case: Case,
-        response: WSGIResponse,
+        response: WSGIResponse | None,
         headers: dict[str, Any],
-        elapsed: float,
+        elapsed: float | None,
         status: Status,
         checks: list[Check],
     ) -> None:
@@ -1209,6 +1248,3 @@ class TestResultSet:
     def add_warning(self, warning: str) -> None:
         """Add a new warning to the warnings list."""
         self.warnings.append(warning)
-
-
-CheckFunction = Callable[["GenericResponse", Case], Optional[bool]]

schemathesis/runner/__init__.py

@@ -4,7 +4,6 @@ from random import Random
 from typing import TYPE_CHECKING, Any, Callable, Generator, Iterable
 from urllib.parse import urlparse
 
-from .._override import CaseOverride
 from ..constants import (
     DEFAULT_DEADLINE,
     DEFAULT_STATEFUL_RECURSION_LIMIT,
@@ -22,16 +21,17 @@ from ..targets import DEFAULT_TARGETS, Target
 from ..transports import RequestConfig
 from ..transports.auth import get_requests_auth
 from ..types import Filter, NotSet, RawAuth, RequestCert
+from . import events
 from .probes import ProbeConfig
 
 if TYPE_CHECKING:
     import hypothesis
 
+    from .._override import CaseOverride
     from ..models import CheckFunction
     from ..schemas import BaseSchema
     from ..service.client import ServiceClient
     from ..stateful import Stateful
-    from . import events
     from .impl import BaseRunner
 
 
@@ -347,6 +347,7 @@ def from_schema(
     exit_first: bool = False,
     max_failures: int | None = None,
     started_at: str | None = None,
+    unique_data: bool = False,
     dry_run: bool = False,
     store_interactions: bool = False,
     stateful: Stateful | None = None,
@@ -357,9 +358,9 @@ def from_schema(
     service_client: ServiceClient | None = None,
 ) -> BaseRunner:
     import hypothesis
-    from starlette.applications import Starlette
 
     from ..checks import DEFAULT_CHECKS
+    from ..transports.asgi import is_asgi_app
     from .impl import (
         SingleThreadASGIRunner,
         SingleThreadRunner,
@@ -373,7 +374,6 @@ def from_schema(
     probe_config = probe_config or ProbeConfig()
 
     hypothesis_settings = hypothesis_settings or hypothesis.settings(deadline=DEFAULT_DEADLINE)
-    generation_config = generation_config or GenerationConfig()
     request_config = RequestConfig(
         timeout=request_timeout,
         tls_verify=request_tls_verify,
@@ -405,6 +405,7 @@ def from_schema(
                 exit_first=exit_first,
                 max_failures=max_failures,
                 started_at=started_at,
+                unique_data=unique_data,
                 dry_run=dry_run,
                 store_interactions=store_interactions,
                 stateful=stateful,
@@ -414,7 +415,7 @@ def from_schema(
                 probe_config=probe_config,
                 service_client=service_client,
             )
-        if isinstance(schema.app, Starlette):
+        if is_asgi_app(schema.app):
             return ThreadPoolASGIRunner(
                 schema=schema,
                 checks=checks,
@@ -430,6 +431,7 @@ def from_schema(
                 exit_first=exit_first,
                 max_failures=max_failures,
                 started_at=started_at,
+                unique_data=unique_data,
                 dry_run=dry_run,
                 store_interactions=store_interactions,
                 stateful=stateful,
@@ -455,6 +457,7 @@ def from_schema(
             exit_first=exit_first,
             max_failures=max_failures,
             started_at=started_at,
+            unique_data=unique_data,
             dry_run=dry_run,
             store_interactions=store_interactions,
             stateful=stateful,
@@ -481,6 +484,7 @@ def from_schema(
             exit_first=exit_first,
             max_failures=max_failures,
             started_at=started_at,
+            unique_data=unique_data,
             dry_run=dry_run,
             store_interactions=store_interactions,
             stateful=stateful,
@@ -490,7 +494,7 @@ def from_schema(
             probe_config=probe_config,
             service_client=service_client,
         )
-    if isinstance(schema.app, Starlette):
+    if is_asgi_app(schema.app):
         return SingleThreadASGIRunner(
             schema=schema,
             checks=checks,
@@ -506,6 +510,7 @@ def from_schema(
             exit_first=exit_first,
             max_failures=max_failures,
             started_at=started_at,
+            unique_data=unique_data,
             dry_run=dry_run,
             store_interactions=store_interactions,
             stateful=stateful,
@@ -530,6 +535,7 @@ def from_schema(
         exit_first=exit_first,
         max_failures=max_failures,
         started_at=started_at,
+        unique_data=unique_data,
         dry_run=dry_run,
         store_interactions=store_interactions,
         stateful=stateful,

schemathesis/runner/events.py

@@ -7,12 +7,12 @@ from dataclasses import asdict, dataclass, field
 from typing import TYPE_CHECKING, Any
 
 from ..exceptions import RuntimeErrorType, SchemaError, SchemaErrorType, format_exception
-from ..generation import DataGenerationMethod
 from ..internal.datetime import current_datetime
 from ..internal.result import Err, Ok, Result
 from .serialization import SerializedError, SerializedTestResult
 
 if TYPE_CHECKING:
+    from ..generation import DataGenerationMethod
     from ..models import APIOperation, Status, TestResult, TestResultSet
     from ..schemas import BaseSchema, Specification
     from ..service.models import AnalysisResult

schemathesis/runner/impl/context.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from ...constants import NOT_SET
+from ...models import TestResult, TestResultSet
+
+if TYPE_CHECKING:
+    import threading
+
+    from ...exceptions import OperationSchemaError
+    from ...models import Case
+    from ...types import NotSet
+
+
+@dataclass
+class RunnerContext:
+    """Holds context shared for a test run."""
+
+    data: TestResultSet
+    seed: int | None
+    stop_event: threading.Event
+    unique_data: bool
+    outcome_cache: dict[int, BaseException | None]
+
+    __slots__ = ("data", "seed", "stop_event", "unique_data", "outcome_cache")
+
+    def __init__(self, *, seed: int | None, stop_event: threading.Event, unique_data: bool) -> None:
+        self.data = TestResultSet(seed=seed)
+        self.seed = seed
+        self.stop_event = stop_event
+        self.outcome_cache = {}
+        self.unique_data = unique_data
+
+    @property
+    def is_stopped(self) -> bool:
+        return self.stop_event.is_set()
+
+    @property
+    def has_all_not_found(self) -> bool:
+        """Check if all responses are 404."""
+        has_not_found = False
+        for entry in self.data.results:
+            for check in entry.checks:
+                if check.response is not None:
+                    if check.response.status_code == 404:
+                        has_not_found = True
+                    else:
+                        # There are non-404 responses, no reason to check any other response
+                        return False
+        # Only happens if all responses are 404, or there are no responses at all.
+        # In the first case, it returns True, for the latter - False
+        return has_not_found
+
+    def add_result(self, result: TestResult) -> None:
+        self.data.append(result)
+
+    def add_generic_error(self, error: OperationSchemaError) -> None:
+        self.data.generic_errors.append(error)
+
+    def add_warning(self, message: str) -> None:
+        self.data.add_warning(message)
+
+    def cache_outcome(self, case: Case, outcome: BaseException | None) -> None:
+        self.outcome_cache[hash(case)] = outcome
+
+    def get_cached_outcome(self, case: Case) -> BaseException | None | NotSet:
+        return self.outcome_cache.get(hash(case), NOT_SET)
+
+
+ALL_NOT_FOUND_WARNING_MESSAGE = "All API responses have a 404 status code. Did you specify the proper API location?"