schemathesis 3.13.0__py3-none-any.whl → 4.4.2__py3-none-any.whl

schemathesis/specs/openapi/media_types.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Collection
+
+from schemathesis.transport import SerializationContext
+from schemathesis.transport.asgi import ASGI_TRANSPORT
+from schemathesis.transport.requests import REQUESTS_TRANSPORT
+from schemathesis.transport.wsgi import WSGI_TRANSPORT
+
+if TYPE_CHECKING:
+    from hypothesis import strategies as st
+
+
+MEDIA_TYPES: dict[str, st.SearchStrategy[bytes]] = {}
+
+
+def register_media_type(name: str, strategy: st.SearchStrategy[bytes], *, aliases: Collection[str] = ()) -> None:
+    r"""Register a custom Hypothesis strategy for generating media type content.
+
+    Args:
+        name: Media type name that matches your OpenAPI requestBody content type
+        strategy: Hypothesis strategy that generates bytes for this media type
+        aliases: Additional media type names that use the same strategy
+
+    Example:
+        ```python
+        import schemathesis
+        from hypothesis import strategies as st
+
+        # Register PDF file strategy
+        pdf_strategy = st.sampled_from([
+            b"%PDF-1.4\n1 0 obj\n<<\n/Type /Catalog\n>>\nendobj\n%%EOF",
+            b"%PDF-1.5\n%\xe2\xe3\xcf\xd3\n1 0 obj\n<<\n/Type /Catalog\n>>\nendobj\n%%EOF"
+        ])
+        schemathesis.openapi.media_type("application/pdf", pdf_strategy)
+
+        # Dynamic content generation
+        @st.composite
+        def xml_content(draw):
+            tag = draw(st.text(min_size=3, max_size=10))
+            content = draw(st.text(min_size=1, max_size=50))
+            return f"<?xml version='1.0'?><{tag}>{content}</{tag}>".encode()
+
+        schemathesis.openapi.media_type("application/xml", xml_content())
+        ```
+
+    Schema usage:
+        ```yaml
+        requestBody:
+          content:
+            application/pdf:        # Uses your PDF strategy
+              schema:
+                type: string
+                format: binary
+            application/xml:        # Uses your XML strategy
+              schema:
+                type: string
+                format: binary
+        ```
+
+    """
+
+    @REQUESTS_TRANSPORT.serializer(name, *aliases)
+    @ASGI_TRANSPORT.serializer(name, *aliases)
+    @WSGI_TRANSPORT.serializer(name, *aliases)
+    def serialize(ctx: SerializationContext, value: Any) -> dict[str, Any]:
+        return {"data": value}
+
+    MEDIA_TYPES[name] = strategy
+    for alias in aliases:
+        MEDIA_TYPES[alias] = strategy
+
+
+def unregister_all() -> None:
+    MEDIA_TYPES.clear()

schemathesis/specs/openapi/negative/__init__.py

@@ -1,85 +1,73 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
 from functools import lru_cache
-from typing import Any, Dict, Optional, Tuple
+from typing import TYPE_CHECKING, Any
+from urllib.parse import urlencode
 
-import attr
 import jsonschema
 from hypothesis import strategies as st
 from hypothesis_jsonschema import from_schema
 
-from .mutations import MutationContext
-from .types import Draw, Schema
+from schemathesis.config import GenerationConfig
+from schemathesis.core.jsonschema import ALL_KEYWORDS
+from schemathesis.core.jsonschema.types import JsonSchema
+from schemathesis.core.parameters import ParameterLocation
+
+from .mutations import MutationContext, MutationMetadata
+
+if TYPE_CHECKING:
+    from .types import Draw, Schema
+
+
+@dataclass
+class GeneratedValue:
+    """Wrapper for generated values with optional mutation metadata.
+
+    This allows us to pass both the value and metadata through the generation pipeline
+    without using tuples, making the code cleaner and type-safe.
+    """
+
+    value: Any
+    meta: MutationMetadata | None
 
+    __slots__ = ("value", "meta")
 
-@attr.s(slots=True, hash=False)
+
+@dataclass
 class CacheKey:
     """A cache key for API Operation / location.
 
     Carries the schema around but don't use it for hashing to simplify LRU cache usage.
     """
 
-    operation_name: str = attr.ib()
-    location: str = attr.ib()
-    schema: Schema = attr.ib()
+    operation_name: str
+    location: str
+    schema: JsonSchema
+    validator_cls: type[jsonschema.Validator]
+
+    __slots__ = ("operation_name", "location", "schema", "validator_cls")
 
     def __hash__(self) -> int:
         return hash((self.operation_name, self.location))
 
 
-@lru_cache()
-def get_validator(cache_key: CacheKey) -> jsonschema.Draft4Validator:
+@lru_cache
+def get_validator(cache_key: CacheKey) -> jsonschema.Validator:
     """Get JSON Schema validator for the given schema."""
     # Each operation / location combo has only a single schema, therefore could be cached
-    return jsonschema.Draft4Validator(cache_key.schema)
-
-
-ALL_KEYWORDS = {
-    "additionalItems",
-    "additionalProperties",
-    "allOf",
-    "anyOf",
-    "const",
-    "contains",
-    "contentEncoding",
-    "contentMediaType",
-    "dependencies",
-    "enum",
-    "else",
-    "exclusiveMaximum",
-    "exclusiveMinimum",
-    "format",
-    "if",
-    "items",
-    "maxItems",
-    "maxLength",
-    "maxProperties",
-    "maximum",
-    "minItems",
-    "minLength",
-    "minProperties",
-    "minimum",
-    "multipleOf",
-    "not",
-    "oneOf",
-    "pattern",
-    "patternProperties",
-    "properties",
-    "propertyNames",
-    "$ref",
-    "required",
-    "then",
-    "type",
-    "uniqueItems",
-}
-
-
-@lru_cache()
-def split_schema(cache_key: CacheKey) -> Tuple[Schema, Schema]:
+    return cache_key.validator_cls(cache_key.schema)
+
+
+@lru_cache
+def split_schema(cache_key: CacheKey) -> tuple[Schema, Schema]:
     """Split the schema in two parts.
 
     The first one contains only validation JSON Schema keywords, the second one everything else.
     """
     keywords, non_keywords = {}, {}
-    for keyword, value in cache_key.schema.items():
+    schema = {} if isinstance(cache_key.schema, bool) else cache_key.schema
+    for keyword, value in schema.items():
         if keyword in ALL_KEYWORDS:
             keywords[keyword] = value
         else:
@@ -88,29 +76,90 @@ def split_schema(cache_key: CacheKey) -> Tuple[Schema, Schema]:
 
 
 def negative_schema(
-    schema: Schema,
+    schema: JsonSchema,
     operation_name: str,
-    location: str,
-    media_type: Optional[str],
+    location: ParameterLocation,
+    media_type: str | None,
+    generation_config: GenerationConfig,
     *,
-    custom_formats: Dict[str, st.SearchStrategy[str]],
+    custom_formats: dict[str, st.SearchStrategy[str]],
+    validator_cls: type[jsonschema.Validator],
 ) -> st.SearchStrategy:
     """A strategy for instances that DO NOT match the input schema.
 
     It is used to cover the input space that is not possible to cover with the "positive" strategy.
+
+    Returns a strategy that produces GeneratedValue instances with mutation metadata.
     """
     # The mutated schema is passed to `from_schema` and guarded against producing instances valid against
     # the original schema.
-    cache_key = CacheKey(operation_name, location, schema)
+    cache_key = CacheKey(operation_name, location, schema, validator_cls)
     validator = get_validator(cache_key)
     keywords, non_keywords = split_schema(cache_key)
-    return mutated(keywords, non_keywords, location, media_type).flatmap(
-        lambda s: from_schema(s, custom_formats=custom_formats).filter(lambda v: not validator.is_valid(v))
-    )
-
 
-@st.composite  # type: ignore
-def mutated(draw: Draw, keywords: Schema, non_keywords: Schema, location: str, media_type: Optional[str]) -> Any:
+    if location == ParameterLocation.QUERY:
+
+        def filter_values(value: dict[str, Any]) -> bool:
+            return is_non_empty_query(value) and not validator.is_valid(value)
+
+    else:
+
+        def filter_values(value: dict[str, Any]) -> bool:
+            return not validator.is_valid(value)
+
+    def generate_value_with_metadata(value: tuple[dict, MutationMetadata]) -> st.SearchStrategy:
+        schema, metadata = value
+        return (
+            from_schema(
+                schema,
+                custom_formats=custom_formats,
+                allow_x00=generation_config.allow_x00,
+                codec=generation_config.codec,
+            )
+            .filter(filter_values)
+            .map(lambda value: GeneratedValue(value, metadata))
+        )
+
+    return mutated(
+        keywords=keywords,
+        non_keywords=non_keywords,
+        location=location,
+        media_type=media_type,
+        allow_extra_parameters=generation_config.allow_extra_parameters,
+    ).flatmap(generate_value_with_metadata)
+
+
+def is_non_empty_query(query: dict[str, Any]) -> bool:
+    # Whether this query parameters will be encoded to a non-empty query string
+    result = []
+    for key, values in query.items():
+        if isinstance(values, str) or not hasattr(values, "__iter__"):
+            values = [values]
+        for value in values:
+            if value is not None:
+                result.append(
+                    (
+                        key.encode("utf-8") if isinstance(key, str) else key,
+                        value.encode("utf-8") if isinstance(value, str) else value,
+                    )
+                )
+    return urlencode(result, doseq=True) != ""
+
+
+@st.composite  # type: ignore[misc]
+def mutated(
+    draw: Draw,
+    *,
+    keywords: Schema,
+    non_keywords: Schema,
+    location: ParameterLocation,
+    media_type: str | None,
+    allow_extra_parameters: bool,
+) -> Any:
     return MutationContext(
-        keywords=keywords, non_keywords=non_keywords, location=location, media_type=media_type
+        keywords=keywords,
+        non_keywords=non_keywords,
+        location=location,
+        media_type=media_type,
+        allow_extra_parameters=allow_extra_parameters,
     ).mutate(draw)