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

schemathesis/extra/_flask.py

@@ -1,9 +1,12 @@
 from __future__ import annotations
 
-from flask import Flask
+from typing import TYPE_CHECKING
 
 from . import _server
 
+if TYPE_CHECKING:
+    from flask import Flask
+
 
 def run_server(app: Flask, port: int | None = None, timeout: float = 0.05) -> int:
     """Start a thread with the given aiohttp application."""

schemathesis/extra/pytest_plugin.py

@@ -3,12 +3,11 @@ from __future__ import annotations
 import unittest
 from contextlib import contextmanager
 from functools import partial
-from typing import Any, Callable, Generator, Type, cast
+from typing import TYPE_CHECKING, Any, Callable, Generator, Type, cast
 
 import pytest
 from _pytest import fixtures, nodes
 from _pytest.config import hookimpl
-from _pytest.fixtures import FuncFixtureInfo
 from _pytest.python import Class, Function, FunctionDefinition, Metafunc, Module, PyCollector
 from hypothesis import reporting
 from hypothesis.errors import InvalidArgument, Unsatisfiable
@@ -30,7 +29,6 @@ from ..exceptions import (
     UsageError,
 )
 from ..internal.result import Ok, Result
-from ..models import APIOperation
 from ..utils import (
     PARAMETRIZE_MARKER,
     fail_on_no_matches,
@@ -42,6 +40,11 @@ from ..utils import (
     validate_given_args,
 )
 
+if TYPE_CHECKING:
+    from _pytest.fixtures import FuncFixtureInfo
+
+    from ..models import APIOperation
+
 
 class SchemathesisFunction(Function):
     def __init__(

schemathesis/failures.py

@@ -2,12 +2,13 @@ from __future__ import annotations
 
 import textwrap
 from dataclasses import dataclass
-from json import JSONDecodeError
 from typing import TYPE_CHECKING, Any
 
 from schemathesis.internal.output import OutputConfig
 
 if TYPE_CHECKING:
+    from json import JSONDecodeError
+
     from graphql.error import GraphQLFormattedError
     from jsonschema import ValidationError
 

schemathesis/filters.py

@@ -54,7 +54,7 @@ class Matcher:
             func = partial(by_value_list, attribute=attribute, expected=expected)
         else:
             func = partial(by_value, attribute=attribute, expected=expected)
-        label = f"{attribute}={repr(expected)}"
+        label = f"{attribute}={expected!r}"
         return cls(func, label=label, _hash=hash(label))
 
     @classmethod
@@ -68,7 +68,7 @@ class Matcher:
                 flags = 0
             regex = re.compile(regex, flags=flags)
         func = partial(by_regex, attribute=attribute, regex=regex)
-        label = f"{attribute}_regex={repr(regex)}"
+        label = f"{attribute}_regex={regex!r}"
         return cls(func, label=label, _hash=hash(label))
 
     def match(self, ctx: HasAPIOperation) -> bool:

schemathesis/generation/__init__.py

@@ -4,8 +4,8 @@ import random
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING
 
-from ._hypothesis import add_single_example, combine_strategies, get_single_example  # noqa: E402
-from ._methods import DataGenerationMethod, DataGenerationMethodInput  # noqa: E402
+from ._hypothesis import add_single_example, combine_strategies, get_single_example
+from ._methods import DataGenerationMethod, DataGenerationMethodInput
 
 if TYPE_CHECKING:
     from hypothesis.strategies import SearchStrategy

schemathesis/generation/_hypothesis.py

@@ -9,7 +9,7 @@ if TYPE_CHECKING:
     from hypothesis import strategies as st
 
 
-@lru_cache()
+@lru_cache
 def default_settings() -> settings:
     from hypothesis import HealthCheck, Phase, Verbosity, settings
 

schemathesis/generation/coverage.py

@@ -4,7 +4,7 @@ import json
 from contextlib import contextmanager, suppress
 from dataclasses import dataclass, field
 from functools import lru_cache
-from typing import Any, Generator, Set, Type, TypeVar, cast
+from typing import Any, Generator, TypeVar, cast
 
 import jsonschema
 from hypothesis import strategies as st
@@ -140,8 +140,8 @@ def _ignore_unfixable(
     *,
     # Cache exception types here as `jsonschema` uses a custom `__getattr__` on the module level
     # and it may cause errors during the interpreter shutdown
-    ref_error: Type[Exception] = jsonschema.RefResolutionError,
-    schema_error: Type[Exception] = jsonschema.SchemaError,
+    ref_error: type[Exception] = jsonschema.RefResolutionError,
+    schema_error: type[Exception] = jsonschema.SchemaError,
 ) -> Generator:
     try:
         yield
@@ -172,7 +172,7 @@ def cover_schema_iter(ctx: CoverageContext, schema: dict | bool) -> Generator[Ge
             yield from _cover_positive_for_type(ctx, schema, ty)
     if DataGenerationMethod.negative in ctx.data_generation_methods:
         template = None
-        seen: Set[Any | tuple[type, str]] = set()
+        seen: set[Any | tuple[type, str]] = set()
         for key, value in schema.items():
             with _ignore_unfixable():
                 if key == "enum":
@@ -238,7 +238,7 @@ def _get_properties(schema: dict | bool) -> dict | bool:
     if isinstance(schema, dict):
         if "example" in schema:
             return {"const": schema["example"]}
-        if "examples" in schema and schema["examples"]:
+        if schema.get("examples"):
             return {"enum": schema["examples"]}
         if schema.get("type") == "object":
             return _get_template_schema(schema, "object")

schemathesis/graphql.py

@@ -1,4 +1,3 @@
-# Public API
 from .specs.graphql import nodes  # noqa: F401
 from .specs.graphql.loaders import from_asgi, from_dict, from_file, from_path, from_url, from_wsgi  # noqa: F401
 from .specs.graphql.scalars import scalar  # noqa: F401

schemathesis/hooks.py

@@ -6,11 +6,10 @@ from copy import deepcopy
 from dataclasses import dataclass, field
 from enum import Enum, unique
 from functools import partial
-from typing import TYPE_CHECKING, Any, Callable, ClassVar, DefaultDict, cast
+from typing import TYPE_CHECKING, Any, Callable, ClassVar, cast
 
 from .filters import FilterSet, attach_filter_chain
 from .internal.deprecation import deprecated_property
-from .types import GenericTest
 
 if TYPE_CHECKING:
     from hypothesis import strategies as st
@@ -18,6 +17,7 @@ if TYPE_CHECKING:
     from .models import APIOperation, Case
     from .schemas import BaseSchema
     from .transports.responses import GenericResponse
+    from .types import GenericTest
 
 
 @unique
@@ -108,7 +108,7 @@ class HookDispatcher:
     """
 
     scope: HookScope
-    _hooks: DefaultDict[str, list[Callable]] = field(default_factory=lambda: defaultdict(list))
+    _hooks: defaultdict[str, list[Callable]] = field(default_factory=lambda: defaultdict(list))
     _specs: ClassVar[dict[str, RegisteredHook]] = {}
 
     def __post_init__(self) -> None:

schemathesis/lazy.py

@@ -2,15 +2,13 @@ from __future__ import annotations
 
 from dataclasses import dataclass, field
 from inspect import signature
-from typing import Any, Callable, Generator
+from typing import TYPE_CHECKING, Any, Callable, Generator
 
 import pytest
-from _pytest.fixtures import FixtureRequest
 from hypothesis.core import HypothesisHandle
 from hypothesis.errors import Flaky
 from hypothesis.internal.escalation import format_exception, get_trimmed_traceback
 from hypothesis.internal.reflection import impersonate
-from pyrate_limiter import Limiter
 from pytest_subtests import SubTests, nullcontext
 
 from ._compat import MultipleFailures, get_interesting_origin
@@ -20,14 +18,10 @@ from .code_samples import CodeSampleStyle
 from .constants import FLAKY_FAILURE_MESSAGE, NOT_SET
 from .exceptions import CheckFailed, OperationSchemaError, SkipTest, get_grouped_exception
 from .filters import FilterSet, FilterValue, MatcherFunc, RegexValue, filter_set_from_components, is_deprecated
-from .generation import DataGenerationMethodInput, GenerationConfig
 from .hooks import HookDispatcher, HookScope
 from .internal.deprecation import warn_filtration_arguments
-from .internal.output import OutputConfig
 from .internal.result import Ok
-from .models import APIOperation
 from .schemas import BaseSchema
-from .types import Filter, GenericTest, NotSet
 from .utils import (
     GivenInput,
     fail_on_no_matches,
@@ -39,6 +33,15 @@ from .utils import (
     validate_given_args,
 )
 
+if TYPE_CHECKING:
+    from _pytest.fixtures import FixtureRequest
+    from pyrate_limiter import Limiter
+
+    from .generation import DataGenerationMethodInput, GenerationConfig
+    from .internal.output import OutputConfig
+    from .models import APIOperation
+    from .types import Filter, GenericTest, NotSet
+
 
 @dataclass
 class LazySchema:

schemathesis/loaders.py

@@ -51,13 +51,13 @@ def _raise_for_status(response: GenericResponse) -> None:
         else:
             type_ = SchemaErrorType.HTTP_CLIENT_ERROR
     else:
-        return None
+        return
     raise SchemaError(message=message, type=type_, url=response.request.url, response=response, extras=[])
 
 
 def load_app(path: str) -> Any:
     """Import an application from a string."""
-    path, name = (re.split(r":(?![\\/])", path, maxsplit=1) + [""])[:2]
+    path, name = ([*re.split(":(?![\\\\/])", path, maxsplit=1), ""])[:2]
     __import__(path)
     # accessing the module from sys.modules returns a proper module, while `__import__`
     # may return a parent module (system dependent)
@@ -92,7 +92,7 @@ def get_yaml_loader() -> type[yaml.SafeLoader]:
                        |[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\.[0-9_]*
                        |[-+]?\.(?:inf|Inf|INF)
                        |\.(?:nan|NaN|NAN))$""",
-            re.X,
+            re.VERBOSE,
         ),
         list("-+0123456789."),
     )

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,
@@ -28,7 +27,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 +36,6 @@ from .constants import (
 )
 from .exceptions import (
     CheckFailed,
-    FailureContext,
     OperationSchemaError,
     SerializationNotPossible,
     SkipTest,
@@ -54,19 +51,22 @@ 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 .schemas import BaseSchema
+    from .serializers import Serializer
     from .stateful import Stateful, StatefulTest
     from .transports.responses import GenericResponse, WSGIResponse
 
@@ -995,7 +995,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 +1003,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 +1035,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 +1047,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 +1137,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:

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
 
 
@@ -357,9 +357,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,
@@ -414,7 +414,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,
@@ -490,7 +490,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,

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,58 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from ...models import TestResult, TestResultSet
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ...exceptions import OperationSchemaError
+    import threading
+
+
+@dataclass
+class RunnerContext:
+    """Holds context shared for a test run."""
+
+    data: TestResultSet
+    seed: int | None
+    stop_event: threading.Event
+
+    __slots__ = ("data", "seed", "stop_event")
+
+    def __init__(self, seed: int | None, stop_event: threading.Event) -> None:
+        self.data = TestResultSet(seed=seed)
+        self.seed = seed
+        self.stop_event = stop_event
+
+    @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)
+
+
+ALL_NOT_FOUND_WARNING_MESSAGE = "All API responses have a 404 status code. Did you specify the proper API location?"