schemathesis 3.39.7__py3-none-any.whl → 4.0.0a2__py3-none-any.whl

schemathesis/generation/case.py

@@ -0,0 +1,190 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any, Mapping
+
+from schemathesis.checks import CHECKS, CheckContext, CheckFunction, run_checks
+from schemathesis.core import NOT_SET, SCHEMATHESIS_TEST_CASE_HEADER, NotSet, curl
+from schemathesis.core.failures import FailureGroup, failure_report_title, format_failures
+from schemathesis.core.transport import Response
+from schemathesis.generation import generate_random_case_id
+from schemathesis.generation.meta import CaseMetadata
+from schemathesis.generation.overrides import Override, store_components
+from schemathesis.hooks import HookContext, dispatch
+from schemathesis.transport.prepare import prepare_request
+
+if TYPE_CHECKING:
+    import requests.auth
+    from requests.structures import CaseInsensitiveDict
+
+    from schemathesis.schemas import APIOperation
+
+
+@dataclass
+class Case:
+    """A single test case parameters."""
+
+    operation: APIOperation
+    method: str
+    path: str
+    # Unique test case identifier
+    id: str = field(default_factory=generate_random_case_id, compare=False)
+    path_parameters: dict[str, Any] | None = None
+    headers: CaseInsensitiveDict | None = None
+    cookies: dict[str, Any] | None = None
+    query: dict[str, Any] | None = None
+    # By default, there is no body, but we can't use `None` as the default value because it clashes with `null`
+    # which is a valid payload.
+    body: list | dict[str, Any] | str | int | float | bool | bytes | NotSet = NOT_SET
+    # The media type for cases with a payload. For example, "application/json"
+    media_type: str | None = None
+
+    meta: CaseMetadata | None = field(compare=False, default=None)
+
+    _auth: requests.auth.AuthBase | None = None
+    _has_explicit_auth: bool = False
+
+    def __post_init__(self) -> None:
+        self._components = store_components(self)
+
+    @property
+    def _override(self) -> Override:
+        return Override.from_components(self._components, self)
+
+    def __repr__(self) -> str:
+        output = f"{self.__class__.__name__}("
+        first = True
+        for name in ("path_parameters", "headers", "cookies", "query", "body"):
+            value = getattr(self, name)
+            if value is not None and not isinstance(value, NotSet):
+                if first:
+                    first = False
+                else:
+                    output += ", "
+                output += f"{name}={value!r}"
+        return f"{output})"
+
+    def __hash__(self) -> int:
+        return hash(self.as_curl_command({SCHEMATHESIS_TEST_CASE_HEADER: "0"}))
+
+    def _repr_pretty_(self, *args: Any, **kwargs: Any) -> None: ...
+
+    def as_curl_command(self, headers: Mapping[str, Any] | None = None, verify: bool = True) -> str:
+        """Construct a curl command for a given case."""
+        request_data = prepare_request(self, headers, self.operation.schema.output_config.sanitize)
+        return curl.generate(
+            method=str(request_data.method),
+            url=str(request_data.url),
+            body=request_data.body,
+            verify=verify,
+            headers=dict(request_data.headers),
+            known_generated_headers=dict(self.headers or {}),
+        )
+
+    def as_transport_kwargs(self, base_url: str | None = None, headers: dict[str, str] | None = None) -> dict[str, Any]:
+        """Convert the test case into a dictionary acceptable by the underlying transport call."""
+        return self.operation.schema.transport.serialize_case(self, base_url=base_url, headers=headers)
+
+    def call(
+        self,
+        base_url: str | None = None,
+        session: requests.Session | None = None,
+        headers: dict[str, Any] | None = None,
+        params: dict[str, Any] | None = None,
+        cookies: dict[str, Any] | None = None,
+        **kwargs: Any,
+    ) -> Response:
+        hook_context = HookContext(operation=self.operation)
+        dispatch("before_call", hook_context, self, **kwargs)
+        if self.operation.app is not None:
+            kwargs["app"] = self.operation.app
+        response = self.operation.schema.transport.send(
+            self,
+            session=session,
+            base_url=base_url,
+            headers=headers,
+            params=params,
+            cookies=cookies,
+            **kwargs,
+        )
+        dispatch("after_call", hook_context, self, response)
+        return response
+
+    def validate_response(
+        self,
+        response: Response,
+        checks: list[CheckFunction] | None = None,
+        additional_checks: list[CheckFunction] | None = None,
+        excluded_checks: list[CheckFunction] | None = None,
+        headers: dict[str, Any] | None = None,
+        transport_kwargs: dict[str, Any] | None = None,
+    ) -> None:
+        """Validate application response.
+
+        By default, all available checks will be applied.
+
+        :param response: Application response.
+        :param checks: A tuple of check functions that accept ``response`` and ``case``.
+        :param additional_checks: A tuple of additional checks that will be executed after ones from the ``checks``
+            argument.
+        :param excluded_checks: Checks excluded from the default ones.
+        """
+        __tracebackhide__ = True
+        from requests.structures import CaseInsensitiveDict
+
+        checks = [
+            check
+            for check in list(checks or CHECKS.get_all()) + list(additional_checks or [])
+            if check not in set(excluded_checks or [])
+        ]
+
+        ctx = CheckContext(
+            override=self._override,
+            auth=None,
+            headers=CaseInsensitiveDict(headers) if headers else None,
+            config={},
+            transport_kwargs=transport_kwargs,
+            recorder=None,
+        )
+        failures = run_checks(
+            case=self,
+            response=response,
+            ctx=ctx,
+            checks=checks,
+            on_failure=lambda _, collected, failure: collected.add(failure),
+        )
+        if failures:
+            _failures = list(failures)
+            message = failure_report_title(_failures) + "\n"
+            verify = getattr(response, "verify", True)
+            curl = self.as_curl_command(headers=dict(response.request.headers), verify=verify)
+            message += format_failures(
+                case_id=None,
+                response=response,
+                failures=_failures,
+                curl=curl,
+                config=self.operation.schema.output_config,
+            )
+            raise FailureGroup(_failures, message) from None
+
+    def call_and_validate(
+        self,
+        base_url: str | None = None,
+        session: requests.Session | None = None,
+        headers: dict[str, Any] | None = None,
+        checks: list[CheckFunction] | None = None,
+        additional_checks: list[CheckFunction] | None = None,
+        excluded_checks: list[CheckFunction] | None = None,
+        **kwargs: Any,
+    ) -> Response:
+        __tracebackhide__ = True
+        response = self.call(base_url, session, headers, **kwargs)
+        self.validate_response(
+            response,
+            checks,
+            headers=headers,
+            additional_checks=additional_checks,
+            excluded_checks=excluded_checks,
+            transport_kwargs=kwargs,
+        )
+        return response

schemathesis/generation/coverage.py

@@ -16,14 +16,16 @@ from hypothesis_jsonschema import from_schema
 from hypothesis_jsonschema._canonicalise import canonicalish
 from hypothesis_jsonschema._from_schema import STRING_FORMATS as BUILT_IN_STRING_FORMATS
 
-from ..constants import NOT_SET
-from ..internal.copy import fast_deepcopy
+from schemathesis.core import NOT_SET
+from schemathesis.core.compat import RefResolutionError
+from schemathesis.core.transforms import deepclone
+from schemathesis.core.validation import has_invalid_characters, is_latin_1_encodable
+from schemathesis.generation import GenerationMode
+from schemathesis.generation.hypothesis import examples
+
 from ..specs.openapi.converter import update_pattern_in_schema
 from ..specs.openapi.formats import STRING_FORMATS, get_default_format_strategies
 from ..specs.openapi.patterns import update_quantifier
-from ..transports.headers import has_invalid_characters, is_latin_1_encodable
-from ._hypothesis import get_single_example
-from ._methods import DataGenerationMethod
 
 
 def _replace_zero_with_nonzero(x: float) -> float:
@@ -62,18 +64,18 @@ UNKNOWN_PROPERTY_VALUE = 42
 @dataclass
 class GeneratedValue:
     value: Any
-    data_generation_method: DataGenerationMethod
+    generation_mode: GenerationMode
     description: str
     parameter: str | None
     location: str | None
 
-    __slots__ = ("value", "data_generation_method", "description", "parameter", "location")
+    __slots__ = ("value", "generation_mode", "description", "parameter", "location")
 
     @classmethod
     def with_positive(cls, value: Any, *, description: str) -> GeneratedValue:
         return cls(
             value=value,
-            data_generation_method=DataGenerationMethod.positive,
+            generation_mode=GenerationMode.POSITIVE,
             description=description,
             location=None,
             parameter=None,
@@ -85,7 +87,7 @@ class GeneratedValue:
     ) -> GeneratedValue:
         return cls(
             value=value,
-            data_generation_method=DataGenerationMethod.negative,
+            generation_mode=GenerationMode.NEGATIVE,
             description=description,
             location=location,
             parameter=parameter,
@@ -98,28 +100,26 @@ NegativeValue = GeneratedValue.with_negative
 
 @lru_cache(maxsize=128)
 def cached_draw(strategy: st.SearchStrategy) -> Any:
-    return get_single_example(strategy)
+    return examples.generate_one(strategy)
 
 
 @dataclass
 class CoverageContext:
-    data_generation_methods: list[DataGenerationMethod]
+    generation_modes: list[GenerationMode]
     location: str
     path: list[str | int]
 
-    __slots__ = ("location", "data_generation_methods", "path")
+    __slots__ = ("location", "generation_modes", "path")
 
     def __init__(
         self,
         *,
         location: str,
-        data_generation_methods: list[DataGenerationMethod] | None = None,
+        generation_modes: list[GenerationMode] | None = None,
         path: list[str | int] | None = None,
     ) -> None:
         self.location = location
-        self.data_generation_methods = (
-            data_generation_methods if data_generation_methods is not None else DataGenerationMethod.all()
-        )
+        self.generation_modes = generation_modes if generation_modes is not None else GenerationMode.all()
         self.path = path or []
 
     @contextmanager
@@ -137,14 +137,14 @@ class CoverageContext:
     def with_positive(self) -> CoverageContext:
         return CoverageContext(
             location=self.location,
-            data_generation_methods=[DataGenerationMethod.positive],
+            generation_modes=[GenerationMode.POSITIVE],
             path=self.path,
         )
 
     def with_negative(self) -> CoverageContext:
         return CoverageContext(
             location=self.location,
-            data_generation_methods=[DataGenerationMethod.negative],
+            generation_modes=[GenerationMode.NEGATIVE],
             path=self.path,
         )
 
@@ -255,7 +255,7 @@ def _cover_positive_for_type(
         template = ctx.generate_from_schema(template_schema)
     else:
         template = None
-    if DataGenerationMethod.positive in ctx.data_generation_methods:
+    if GenerationMode.POSITIVE in ctx.generation_modes:
         ctx = ctx.with_positive()
         enum = schema.get("enum", NOT_SET)
         const = schema.get("const", NOT_SET)
@@ -298,7 +298,7 @@ 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,
+    ref_error: type[Exception] = RefResolutionError,
     schema_error: type[Exception] = jsonschema.SchemaError,
 ) -> Generator:
     try:
@@ -333,7 +333,7 @@ def cover_schema_iter(
     for ty in types:
         with _ignore_unfixable():
             yield from _cover_positive_for_type(ctx, schema, ty)
-    if DataGenerationMethod.negative in ctx.data_generation_methods:
+    if GenerationMode.NEGATIVE in ctx.generation_modes:
         template = None
         for key, value in schema.items():
             with _ignore_unfixable(), ctx.at(key):
@@ -467,7 +467,7 @@ def _get_properties(schema: dict | bool) -> dict | bool:
             return {"enum": schema["examples"]}
         if schema.get("type") == "object":
             return _get_template_schema(schema, "object")
-        _schema = fast_deepcopy(schema)
+        _schema = deepclone(schema)
         update_pattern_in_schema(_schema)
         return _schema
     return schema

schemathesis/{_patches.py → generation/hypothesis/__init__.py}

@@ -1,14 +1,23 @@
-"""A set of performance-related patches."""
-
 from typing import Any
 
+# Maximum test running time
+DEFAULT_DEADLINE = 15000
+
 
-def install() -> None:
+def setup() -> None:
+    from hypothesis.internal.entropy import deterministic_PRNG
     from hypothesis.internal.reflection import is_first_param_referenced_in_function
     from hypothesis.strategies._internal import core
     from hypothesis_jsonschema import _from_schema, _resolve
 
-    from .internal.copy import fast_deepcopy
+    from schemathesis.core.transforms import deepclone
+
+    # Forcefully initializes Hypothesis' global PRNG to avoid races that initialize it
+    # if e.g. Schemathesis CLI is used with multiple workers
+    with deterministic_PRNG():
+        pass
+
+    # A set of performance-related patches
 
     # This one is used a lot, and under the hood it re-parses the AST of the same function
     def _is_first_param_referenced_in_function(f: Any) -> bool:
@@ -17,5 +26,5 @@ def install() -> None:
         return is_first_param_referenced_in_function(f)
 
     core.is_first_param_referenced_in_function = _is_first_param_referenced_in_function  # type: ignore
-    _resolve.deepcopy = fast_deepcopy  # type: ignore
-    _from_schema.deepcopy = fast_deepcopy  # type: ignore
+    _resolve.deepcopy = deepclone  # type: ignore
+    _from_schema.deepcopy = deepclone  # type: ignore