schemathesis 3.25.6__py3-none-any.whl → 3.39.7__py3-none-any.whl

schemathesis/specs/openapi/_hypothesis.py

@@ -1,75 +1,43 @@
 from __future__ import annotations
-import string
-from base64 import b64encode
+
+import time
 from contextlib import suppress
 from dataclasses import dataclass
-from functools import lru_cache
 from typing import Any, Callable, Dict, Iterable, Optional
 from urllib.parse import quote_plus
 from weakref import WeakKeyDictionary
 
-from hypothesis import strategies as st, reject
+from hypothesis import reject
+from hypothesis import strategies as st
 from hypothesis_jsonschema import from_schema
-from requests.auth import _basic_auth_str
 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 .formats import STRING_FORMATS
-from ... import auths, serializers
+from ...exceptions import BodyInGetRequestError, SerializationNotPossible
 from ...generation import DataGenerationMethod, GenerationConfig
-from ...internal.copy import fast_deepcopy
-from ...exceptions import SerializationNotPossible, BodyInGetRequestError
 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, cant_serialize
+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 ...serializers import Binary
-from ...utils import compose, skip
+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
 from .negative import negative_schema
 from .negative.utils import can_negate
-from .parameters import OpenAPIBody, parameters_to_json_schema
+from .parameters import OpenAPIBody, OpenAPIParameter, parameters_to_json_schema
 from .utils import is_header_location
 
-HEADER_FORMAT = "_header_value"
 SLASH = "/"
 StrategyFactory = Callable[[Dict[str, Any], str, str, Optional[str], GenerationConfig], st.SearchStrategy]
 
 
-def header_values(blacklist_characters: str = "\n\r") -> st.SearchStrategy[str]:
-    return st.text(alphabet=st.characters(min_codepoint=0, max_codepoint=255, blacklist_characters="\n\r"))
-
-
-@lru_cache
-def get_default_format_strategies() -> dict[str, st.SearchStrategy]:
-    """Get all default "format" strategies."""
-
-    def make_basic_auth_str(item: tuple[str, str]) -> str:
-        return _basic_auth_str(*item)
-
-    latin1_text = st.text(alphabet=st.characters(min_codepoint=0, max_codepoint=255))
-
-    # Define valid characters here to avoid filtering them out in `is_valid_header` later
-    header_value = header_values()
-
-    return {
-        "binary": st.binary().map(Binary),
-        "byte": st.binary().map(lambda x: b64encode(x).decode()),
-        # RFC 7230, Section 3.2.6
-        "_header_name": st.text(
-            min_size=1, alphabet=st.sampled_from("!#$%&'*+-.^_`|~" + string.digits + string.ascii_letters)
-        ),
-        # Header values with leading non-visible chars can't be sent with `requests`
-        HEADER_FORMAT: header_value.map(str.lstrip),
-        "_basic_auth": st.tuples(latin1_text, latin1_text).map(make_basic_auth_str),
-        "_bearer_auth": header_value.map("Bearer {}".format),
-    }
-
-
 def is_valid_header(headers: dict[str, Any]) -> bool:
     """Verify if the generated headers are valid."""
     for name, value in headers.items():
@@ -117,6 +85,7 @@ def get_case_strategy(
     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.
 
@@ -130,6 +99,7 @@ def get_case_strategy(
     The primary purpose of this behavior is to prevent sending incomplete explicit examples by generating missing parts
     as it works with `body`.
     """
+    start = time.monotonic()
     strategy_factory = DATA_GENERATION_METHOD_TO_STRATEGY_FACTORY[generator]
 
     context = HookContext(operation)
@@ -175,6 +145,11 @@ def get_case_strategy(
         else:
             body_ = ValueContainer(value=body, location="body", generator=None)
     else:
+        # This explicit body payload comes for a media type that has a custom strategy registered
+        # Such strategies only support binary payloads, otherwise they can't be serialized
+        if not isinstance(body, bytes) and media_type in MEDIA_TYPES:
+            all_media_types = operation.get_request_payload_content_types()
+            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:
@@ -187,6 +162,7 @@ def get_case_strategy(
             reject()
     instance = Case(
         operation=operation,
+        generation_time=time.monotonic() - start,
         media_type=media_type,
         path_parameters=path_parameters_.value,
         headers=CaseInsensitiveDict(headers_.value) if headers_.value is not None else headers_.value,
@@ -194,6 +170,18 @@ def get_case_strategy(
         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,
+        ),
     )
     auth_context = auths.AuthContext(
         operation=operation,
@@ -212,6 +200,8 @@ def _get_body_strategy(
     operation: APIOperation,
     generation_config: GenerationConfig,
 ) -> st.SearchStrategy:
+    if parameter.media_type in MEDIA_TYPES:
+        return MEDIA_TYPES[parameter.media_type]
     # The cache key relies on object ids, which means that the parameter should not be mutated
     # Note, the parent schema is not included as each parameter belong only to one schema
     if parameter in _BODY_STRATEGIES_CACHE and strategy_factory in _BODY_STRATEGIES_CACHE[parameter]:
@@ -265,6 +255,8 @@ class ValueContainer:
     location: str
     generator: DataGenerationMethod | None
 
+    __slots__ = ("value", "location", "generator")
+
     @property
     def is_generated(self) -> bool:
         """If value was generated."""
@@ -332,6 +324,22 @@ def can_negate_headers(operation: APIOperation, location: str) -> bool:
     return any(header != {"type": "string"} for header in headers.values())
 
 
+def get_schema_for_location(
+    operation: APIOperation, location: str, parameters: Iterable[OpenAPIParameter]
+) -> 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"])
+        for prop in schema.get("properties", {}).values():
+            if prop.get("type") == "string":
+                prop.setdefault("minLength", 1)
+    return operation.schema.prepare_schema(schema)
+
+
 def get_parameters_strategy(
     operation: APIOperation,
     strategy_factory: StrategyFactory,
@@ -346,13 +354,7 @@ def get_parameters_strategy(
         nested_cache_key = (strategy_factory, location, tuple(sorted(exclude)))
         if operation in _PARAMETER_STRATEGIES_CACHE and nested_cache_key in _PARAMETER_STRATEGIES_CACHE[operation]:
             return _PARAMETER_STRATEGIES_CACHE[operation][nested_cache_key]
-        schema = parameters_to_json_schema(operation, parameters)
-        if not operation.schema.validate_schema and location == "path":
-            # 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 = operation.schema.prepare_schema(schema)
+        schema = get_schema_for_location(operation, location, parameters)
         for name in exclude:
             # Values from `exclude` are not necessarily valid for the schema - they come from user-defined examples
             # that may be invalid
@@ -380,12 +382,10 @@ def get_parameters_strategy(
             # `True` / `False` / `None` improves chances of them passing validation in apps
             # that expect boolean / null types
             # and not aware of Python-specific representation of those types
-            map_func = {
-                "path": compose(quote_all, jsonify_python_specific_types),
-                "query": jsonify_python_specific_types,
-            }.get(location)
-            if map_func:
-                strategy = strategy.map(map_func)  # type: ignore
+            if location == "path":
+                strategy = strategy.map(quote_all).map(jsonify_python_specific_types)
+            elif location == "query":
+                strategy = strategy.map(jsonify_python_specific_types)
         _PARAMETER_STRATEGIES_CACHE.setdefault(operation, {})[nested_cache_key] = strategy
         return strategy
     # No parameters defined for this location
@@ -412,6 +412,17 @@ def jsonify_python_specific_types(value: dict[str, Any]) -> dict[str, Any]:
     return value
 
 
+def _build_custom_formats(
+    custom_formats: dict[str, st.SearchStrategy] | None, generation_config: GenerationConfig
+) -> dict[str, st.SearchStrategy]:
+    custom_formats = {**get_default_format_strategies(), **STRING_FORMATS, **(custom_formats or {})}
+    if generation_config.headers.strategy is not None:
+        custom_formats[HEADER_FORMAT] = generation_config.headers.strategy
+    elif not generation_config.allow_x00:
+        custom_formats[HEADER_FORMAT] = header_values(blacklist_characters="\n\r\x00")
+    return custom_formats
+
+
 def make_positive_strategy(
     schema: dict[str, Any],
     operation_name: str,
@@ -428,9 +439,10 @@ def make_positive_strategy(
         for sub_schema in schema.get("properties", {}).values():
             if list(sub_schema) == ["type"] and sub_schema["type"] == "string":
                 sub_schema.setdefault("format", HEADER_FORMAT)
+    custom_formats = _build_custom_formats(custom_formats, generation_config)
     return from_schema(
         schema,
-        custom_formats={**get_default_format_strategies(), **STRING_FORMATS, **(custom_formats or {})},
+        custom_formats=custom_formats,
         allow_x00=generation_config.allow_x00,
         codec=generation_config.codec,
     )
@@ -449,12 +461,13 @@ def make_negative_strategy(
     generation_config: GenerationConfig,
     custom_formats: dict[str, st.SearchStrategy] | None = None,
 ) -> st.SearchStrategy:
+    custom_formats = _build_custom_formats(custom_formats, generation_config)
     return negative_schema(
         schema,
         operation_name=operation_name,
         location=location,
         media_type=media_type,
-        custom_formats={**get_default_format_strategies(), **STRING_FORMATS, **(custom_formats or {})},
+        custom_formats=custom_formats,
         generation_config=generation_config,
     )
 
@@ -478,7 +491,12 @@ def is_valid_path(parameters: dict[str, Any]) -> bool:
     disallowed_values = (SLASH, "")
 
     return not any(
-        (value in disallowed_values or is_illegal_surrogate(value) or isinstance(value, str) and SLASH in value)
+        (
+            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()
     )