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

schemathesis/specs/openapi/_hypothesis.py

@@ -3,29 +3,35 @@ from __future__ import annotations
 import time
 from contextlib import suppress
 from dataclasses import dataclass
-from typing import Any, Callable, Dict, Iterable, Optional
+from typing import Any, Callable, Dict, Iterable, Optional, Union, cast
 from urllib.parse import quote_plus
 from weakref import WeakKeyDictionary
 
-from hypothesis import reject
+from hypothesis import event, note, reject
 from hypothesis import strategies as st
 from hypothesis_jsonschema import from_schema
-from requests.structures import CaseInsensitiveDict
-from requests.utils import to_key_val_list
-
-from ... import auths, serializers
-from ..._hypothesis import prepare_urlencoded
-from ...constants import NOT_SET
-from ...exceptions import BodyInGetRequestError, SerializationNotPossible
-from ...generation import DataGenerationMethod, GenerationConfig
+
+from schemathesis.core import NOT_SET, NotSet, media_types
+from schemathesis.core.control import SkipTest
+from schemathesis.core.errors import SERIALIZERS_SUGGESTION_MESSAGE, SerializationNotPossible
+from schemathesis.core.transforms import deepclone
+from schemathesis.core.transport import prepare_urlencoded
+from schemathesis.generation.meta import (
+    CaseMetadata,
+    ComponentInfo,
+    ComponentKind,
+    ExplicitPhaseData,
+    GeneratePhaseData,
+    GenerationInfo,
+    PhaseInfo,
+    TestPhase,
+)
+from schemathesis.openapi.generation.filters import is_valid_header, is_valid_path, is_valid_query, is_valid_urlencoded
+from schemathesis.schemas import APIOperation
+
+from ... import auths
+from ...generation import GenerationConfig, GenerationMode
 from ...hooks import HookContext, HookDispatcher, apply_to_all_dispatchers
-from ...internal.copy import fast_deepcopy
-from ...internal.validation import is_illegal_surrogate
-from ...models import APIOperation, Case, GenerationMetadata, TestPhase, cant_serialize
-from ...transports.content_types import parse_content_type
-from ...transports.headers import has_invalid_characters, is_latin_1_encodable
-from ...types import NotSet
-from ...utils import skip
 from .constants import LOCATION_TO_CONTAINER
 from .formats import HEADER_FORMAT, STRING_FORMATS, get_default_format_strategies, header_values
 from .media_types import MEDIA_TYPES
@@ -38,53 +44,21 @@ SLASH = "/"
 StrategyFactory = Callable[[Dict[str, Any], str, str, Optional[str], GenerationConfig], st.SearchStrategy]
 
 
-def is_valid_header(headers: dict[str, Any]) -> bool:
-    """Verify if the generated headers are valid."""
-    for name, value in headers.items():
-        if not is_latin_1_encodable(value):
-            return False
-        if has_invalid_characters(name, value):
-            return False
-    return True
-
-
-def is_valid_query(query: dict[str, Any]) -> bool:
-    """Surrogates are not allowed in a query string.
-
-    `requests` and `werkzeug` will fail to send it to the application.
-    """
-    for name, value in query.items():
-        if is_illegal_surrogate(name) or is_illegal_surrogate(value):
-            return False
-    return True
-
-
-def is_valid_urlencoded(data: Any) -> bool:
-    if data is NOT_SET:
-        return True
-    try:
-        for _, __ in to_key_val_list(data):  # type: ignore[no-untyped-call]
-            pass
-        return True
-    except (TypeError, ValueError):
-        return False
-
-
 @st.composite  # type: ignore
-def get_case_strategy(
+def openapi_cases(
     draw: Callable,
+    *,
     operation: APIOperation,
     hooks: HookDispatcher | None = None,
     auth_storage: auths.AuthStorage | None = None,
-    generator: DataGenerationMethod = DataGenerationMethod.default(),
-    generation_config: GenerationConfig | None = None,
+    generation_mode: GenerationMode = GenerationMode.default(),
+    generation_config: GenerationConfig,
     path_parameters: NotSet | dict[str, Any] = NOT_SET,
     headers: NotSet | dict[str, Any] = NOT_SET,
     cookies: NotSet | dict[str, Any] = NOT_SET,
     query: NotSet | dict[str, Any] = NOT_SET,
     body: Any = NOT_SET,
     media_type: str | None = None,
-    skip_on_not_negated: bool = True,
     phase: TestPhase = TestPhase.GENERATE,
 ) -> Any:
     """A strategy that creates `Case` instances.
@@ -100,46 +74,59 @@ def get_case_strategy(
     as it works with `body`.
     """
     start = time.monotonic()
-    strategy_factory = DATA_GENERATION_METHOD_TO_STRATEGY_FACTORY[generator]
+    strategy_factory = GENERATOR_MODE_TO_STRATEGY_FACTORY[generation_mode]
 
     context = HookContext(operation)
 
-    generation_config = generation_config or operation.schema.generation_config
-
     path_parameters_ = generate_parameter(
-        "path", path_parameters, operation, draw, context, hooks, generator, generation_config
+        "path", path_parameters, operation, draw, context, hooks, generation_mode, generation_config
     )
-    headers_ = generate_parameter("header", headers, operation, draw, context, hooks, generator, generation_config)
-    cookies_ = generate_parameter("cookie", cookies, operation, draw, context, hooks, generator, generation_config)
-    query_ = generate_parameter("query", query, operation, draw, context, hooks, generator, generation_config)
+    headers_ = generate_parameter(
+        "header", headers, operation, draw, context, hooks, generation_mode, generation_config
+    )
+    cookies_ = generate_parameter(
+        "cookie", cookies, operation, draw, context, hooks, generation_mode, generation_config
+    )
+    query_ = generate_parameter("query", query, operation, draw, context, hooks, generation_mode, generation_config)
 
     if body is NOT_SET:
         if operation.body:
-            body_generator = generator
-            if generator.is_negative:
+            body_generator = generation_mode
+            if generation_mode.is_negative:
                 # Consider only schemas that are possible to negate
                 candidates = [item for item in operation.body.items if can_negate(item.as_json_schema(operation))]
                 # Not possible to negate body, fallback to positive data generation
                 if not candidates:
                     candidates = operation.body.items
                     strategy_factory = make_positive_strategy
-                    body_generator = DataGenerationMethod.positive
+                    body_generator = GenerationMode.POSITIVE
             else:
                 candidates = operation.body.items
             parameter = draw(st.sampled_from(candidates))
             strategy = _get_body_strategy(parameter, strategy_factory, operation, generation_config)
             strategy = apply_hooks(operation, context, hooks, strategy, "body")
             # Parameter may have a wildcard media type. In this case, choose any supported one
-            possible_media_types = sorted(serializers.get_matching_media_types(parameter.media_type))
+            possible_media_types = sorted(
+                operation.schema.transport.get_matching_media_types(parameter.media_type), key=lambda x: x[0]
+            )
             if not possible_media_types:
                 all_media_types = operation.get_request_payload_content_types()
-                if all(serializers.get_first_matching_media_type(media_type) is None for media_type in all_media_types):
+                if all(
+                    operation.schema.transport.get_first_matching_media_type(media_type) is None
+                    for media_type in all_media_types
+                ):
                     # None of media types defined for this operation are not supported
                     raise SerializationNotPossible.from_media_types(*all_media_types)
                 # Other media types are possible - avoid choosing this media type in the future
-                cant_serialize(parameter.media_type)
-            media_type = draw(st.sampled_from(possible_media_types))
-            if media_type is not None and parse_content_type(media_type) == ("application", "x-www-form-urlencoded"):
+                event_text = f"Can't serialize data to `{parameter.media_type}`."
+                note(f"{event_text} {SERIALIZERS_SUGGESTION_MESSAGE}")
+                event(event_text)
+                reject()  # type: ignore
+            media_type, _ = draw(st.sampled_from(possible_media_types))
+            if media_type is not None and media_types.parse(media_type) == (
+                "application",
+                "x-www-form-urlencoded",
+            ):
                 strategy = strategy.map(prepare_urlencoded).filter(is_valid_urlencoded)
             body_ = ValueContainer(value=draw(strategy), location="body", generator=body_generator)
         else:
@@ -152,35 +139,43 @@ def get_case_strategy(
             raise SerializationNotPossible.from_media_types(*all_media_types)
         body_ = ValueContainer(value=body, location="body", generator=None)
 
-    if operation.schema.validate_schema and operation.method.upper() == "GET" and operation.body:
-        raise BodyInGetRequestError("GET requests should not contain body parameters.")
     # If we need to generate negative cases but no generated values were negated, then skip the whole test
-    if generator.is_negative and not any_negated_values([query_, cookies_, headers_, path_parameters_, body_]):
-        if skip_on_not_negated:
-            skip(operation.verbose_name)
+    if generation_mode.is_negative and not any_negated_values([query_, cookies_, headers_, path_parameters_, body_]):
+        if generation_config.modes == [GenerationMode.NEGATIVE]:
+            raise SkipTest("Impossible to generate negative test cases")
         else:
             reject()
-    instance = Case(
-        operation=operation,
-        generation_time=time.monotonic() - start,
+
+    _phase_data = {
+        TestPhase.EXPLICIT: ExplicitPhaseData(),
+        TestPhase.GENERATE: GeneratePhaseData(),
+    }[phase]
+    phase_data = cast(Union[ExplicitPhaseData, GeneratePhaseData], _phase_data)
+
+    instance = operation.Case(
         media_type=media_type,
         path_parameters=path_parameters_.value,
-        headers=CaseInsensitiveDict(headers_.value) if headers_.value is not None else headers_.value,
+        headers=headers_.value,
         cookies=cookies_.value,
         query=query_.value,
         body=body_.value,
-        data_generation_method=generator,
-        meta=GenerationMetadata(
-            query=query_.generator,
-            path_parameters=path_parameters_.generator,
-            headers=headers_.generator,
-            cookies=cookies_.generator,
-            body=body_.generator,
-            phase=phase,
-            description=None,
-            location=None,
-            parameter=None,
-            parameter_location=None,
+        meta=CaseMetadata(
+            generation=GenerationInfo(
+                time=time.monotonic() - start,
+                mode=generation_mode,
+            ),
+            phase=PhaseInfo(name=phase, data=phase_data),
+            components={
+                kind: ComponentInfo(mode=value.generator)
+                for kind, value in [
+                    (ComponentKind.QUERY, query_),
+                    (ComponentKind.PATH_PARAMETERS, path_parameters_),
+                    (ComponentKind.HEADERS, headers_),
+                    (ComponentKind.COOKIES, cookies_),
+                    (ComponentKind.BODY, body_),
+                ]
+                if value.generator is not None
+            },
         ),
     )
     auth_context = auths.AuthContext(
@@ -208,7 +203,7 @@ def _get_body_strategy(
         return _BODY_STRATEGIES_CACHE[parameter][strategy_factory]
     schema = parameter.as_json_schema(operation)
     schema = operation.schema.prepare_schema(schema)
-    strategy = strategy_factory(schema, operation.verbose_name, "body", parameter.media_type, generation_config)
+    strategy = strategy_factory(schema, operation.label, "body", parameter.media_type, generation_config)
     if not parameter.is_required:
         strategy |= st.just(NOT_SET)
     _BODY_STRATEGIES_CACHE.setdefault(parameter, {})[strategy_factory] = strategy
@@ -238,7 +233,7 @@ def get_parameters_value(
     strategy = apply_hooks(operation, context, hooks, strategy, location)
     new = draw(strategy)
     if new is not None:
-        copied = fast_deepcopy(value)
+        copied = deepclone(value)
         copied.update(new)
         return copied
     return value
@@ -253,7 +248,7 @@ class ValueContainer:
 
     value: Any
     location: str
-    generator: DataGenerationMethod | None
+    generator: GenerationMode | None
 
     __slots__ = ("value", "location", "generator")
 
@@ -265,7 +260,7 @@ class ValueContainer:
 
 def any_negated_values(values: list[ValueContainer]) -> bool:
     """Check if any generated values are negated."""
-    return any(value.generator == DataGenerationMethod.negative for value in values if value.is_generated)
+    return any(value.generator == GenerationMode.NEGATIVE for value in values if value.is_generated)
 
 
 def generate_parameter(
@@ -275,7 +270,7 @@ def generate_parameter(
     draw: Callable,
     context: HookContext,
     hooks: HookDispatcher | None,
-    generator: DataGenerationMethod,
+    generator: GenerationMode,
     generation_config: GenerationConfig,
 ) -> ValueContainer:
     """Generate a value for a parameter.
@@ -289,13 +284,13 @@ def generate_parameter(
         # If we can't negate any parameter, generate positive ones
         # If nothing else will be negated, then skip the test completely
         strategy_factory = make_positive_strategy
-        generator = DataGenerationMethod.positive
+        generator = GenerationMode.POSITIVE
     else:
-        strategy_factory = DATA_GENERATION_METHOD_TO_STRATEGY_FACTORY[generator]
+        strategy_factory = GENERATOR_MODE_TO_STRATEGY_FACTORY[generator]
     value = get_parameters_value(
         explicit, location, draw, operation, context, hooks, strategy_factory, generation_config
     )
-    used_generator: DataGenerationMethod | None = generator
+    used_generator: GenerationMode | None = generator
     if value == explicit:
         # When we pass `explicit`, then its parts are excluded from generation of the final value
         # If the final value is the same, then other parameters were generated at all
@@ -329,11 +324,7 @@ def get_schema_for_location(
 ) -> dict[str, Any]:
     schema = parameters_to_json_schema(operation, parameters)
     if location == "path":
-        if not operation.schema.validate_schema:
-            # If schema validation is disabled, we try to generate data even if the parameter definition
-            # contains errors.
-            # In this case, we know that the `required` keyword should always be `True`.
-            schema["required"] = list(schema["properties"])
+        schema["required"] = list(schema["properties"])
         for prop in schema.get("properties", {}).values():
             if prop.get("type") == "string":
                 prop.setdefault("minLength", 1)
@@ -365,7 +356,7 @@ def get_parameters_strategy(
             # Nothing to negate - all properties were excluded
             strategy = st.none()
         else:
-            strategy = strategy_factory(schema, operation.verbose_name, location, None, generation_config)
+            strategy = strategy_factory(schema, operation.label, location, None, generation_config)
             serialize = operation.get_parameter_serializer(location)
             if serialize is not None:
                 strategy = strategy.map(serialize)
@@ -472,35 +463,12 @@ def make_negative_strategy(
     )
 
 
-DATA_GENERATION_METHOD_TO_STRATEGY_FACTORY = {
-    DataGenerationMethod.positive: make_positive_strategy,
-    DataGenerationMethod.negative: make_negative_strategy,
+GENERATOR_MODE_TO_STRATEGY_FACTORY = {
+    GenerationMode.POSITIVE: make_positive_strategy,
+    GenerationMode.NEGATIVE: make_negative_strategy,
 }
 
 
-def is_valid_path(parameters: dict[str, Any]) -> bool:
-    """Empty strings ("") are excluded from path by urllib3.
-
-    A path containing to "/" or "%2F" will lead to ambiguous path resolution in
-    many frameworks and libraries, such behaviour have been observed in both
-    WSGI and ASGI applications.
-
-    In this case one variable in the path template will be empty, which will lead to 404 in most of the cases.
-    Because of it this case doesn't bring much value and might lead to false positives results of Schemathesis runs.
-    """
-    disallowed_values = (SLASH, "")
-
-    return not any(
-        (
-            value in disallowed_values
-            or is_illegal_surrogate(value)
-            or isinstance(value, str)
-            and (SLASH in value or "}" in value or "{" in value)
-        )
-        for value in parameters.values()
-    )
-
-
 def quote_all(parameters: dict[str, Any]) -> dict[str, Any]:
     """Apply URL quotation for all values in a dictionary."""
     # Even though, "." is an unreserved character, it has a special meaning in "." and ".." strings.
@@ -530,8 +498,3 @@ def apply_hooks(
     """Apply all hooks related to the given location."""
     container = LOCATION_TO_CONTAINER[location]
     return apply_to_all_dispatchers(operation, context, hooks, strategy, container)
-
-
-def clear_cache() -> None:
-    _PARAMETER_STRATEGIES_CACHE.clear()
-    _BODY_STRATEGIES_CACHE.clear()