schemathesis 3.37.1__py3-none-any.whl → 3.38.0__py3-none-any.whl

schemathesis/generation/coverage.py

@@ -1,21 +1,25 @@
 from __future__ import annotations
 
 import functools
-import json
 import re
 from contextlib import contextmanager, suppress
 from dataclasses import dataclass
 from functools import lru_cache, partial
 from itertools import combinations
-from typing import Any, Generator, Iterator, TypeVar, cast
+from json.encoder import _make_iterencode, c_make_encoder, encode_basestring_ascii  # type: ignore
+from typing import Any, Callable, Generator, Iterator, TypeVar, cast
 
 import jsonschema
 from hypothesis import strategies as st
 from hypothesis.errors import InvalidArgument, Unsatisfiable
 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 ..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 ._hypothesis import get_single_example
 from ._methods import DataGenerationMethod
@@ -38,6 +42,18 @@ JSON_STRATEGY: st.SearchStrategy = st.recursive(
 ARRAY_STRATEGY: st.SearchStrategy = st.lists(JSON_STRATEGY)
 OBJECT_STRATEGY: st.SearchStrategy = st.dictionaries(st.text(), JSON_STRATEGY)
 
+
+STRATEGIES_FOR_TYPE = {
+    "integer": st.integers(),
+    "number": NUMERIC_STRATEGY,
+    "boolean": st.booleans(),
+    "null": st.none(),
+    "string": st.text(),
+    "array": ARRAY_STRATEGY,
+    "object": OBJECT_STRATEGY,
+}
+FORMAT_STRATEGIES = {**BUILT_IN_STRING_FORMATS, **get_default_format_strategies(), **STRING_FORMATS}
+
 UNKNOWN_PROPERTY_KEY = "x-schemathesis-unknown-property"
 UNKNOWN_PROPERTY_VALUE = 42
 
@@ -47,16 +63,24 @@ class GeneratedValue:
     value: Any
     data_generation_method: DataGenerationMethod
     description: str
+    location: str | None
 
-    __slots__ = ("value", "data_generation_method", "description")
+    __slots__ = ("value", "data_generation_method", "description", "location")
 
     @classmethod
     def with_positive(cls, value: Any, *, description: str) -> GeneratedValue:
-        return cls(value=value, data_generation_method=DataGenerationMethod.positive, description=description)
+        return cls(
+            value=value, data_generation_method=DataGenerationMethod.positive, description=description, location=None
+        )
 
     @classmethod
-    def with_negative(cls, value: Any, *, description: str) -> GeneratedValue:
-        return cls(value=value, data_generation_method=DataGenerationMethod.negative, description=description)
+    def with_negative(cls, value: Any, *, description: str, location: str) -> GeneratedValue:
+        return cls(
+            value=value,
+            data_generation_method=DataGenerationMethod.negative,
+            description=description,
+            location=location,
+        )
 
 
 PositiveValue = GeneratedValue.with_positive
@@ -71,35 +95,132 @@ def cached_draw(strategy: st.SearchStrategy) -> Any:
 @dataclass
 class CoverageContext:
     data_generation_methods: list[DataGenerationMethod]
+    location_stack: list[str | int]
 
-    __slots__ = ("data_generation_methods",)
+    __slots__ = ("data_generation_methods", "location_stack")
 
-    def __init__(self, data_generation_methods: list[DataGenerationMethod] | None = None) -> None:
+    def __init__(
+        self,
+        data_generation_methods: list[DataGenerationMethod] | None = None,
+        location_stack: list[str | int] | None = None,
+    ) -> None:
         self.data_generation_methods = (
             data_generation_methods if data_generation_methods is not None else DataGenerationMethod.all()
         )
+        self.location_stack = location_stack or []
+
+    @contextmanager
+    def location(self, key: str | int) -> Generator[None, None, None]:
+        self.location_stack.append(key)
+        try:
+            yield
+        finally:
+            self.location_stack.pop()
+
+    @property
+    def current_location(self) -> str:
+        return "/" + "/".join(str(key) for key in self.location_stack)
+
+    def with_positive(self) -> CoverageContext:
+        return CoverageContext(
+            data_generation_methods=[DataGenerationMethod.positive], location_stack=self.location_stack
+        )
 
-    @classmethod
-    def with_positive(cls) -> CoverageContext:
-        return CoverageContext(data_generation_methods=[DataGenerationMethod.positive])
-
-    @classmethod
-    def with_negative(cls) -> CoverageContext:
-        return CoverageContext(data_generation_methods=[DataGenerationMethod.negative])
+    def with_negative(self) -> CoverageContext:
+        return CoverageContext(
+            data_generation_methods=[DataGenerationMethod.negative], location_stack=self.location_stack
+        )
 
     def generate_from(self, strategy: st.SearchStrategy) -> Any:
         return cached_draw(strategy)
 
-    def generate_from_schema(self, schema: dict) -> Any:
+    def generate_from_schema(self, schema: dict | bool) -> Any:
+        if isinstance(schema, bool):
+            return 0
+        keys = sorted([k for k in schema if not k.startswith("x-") and k not in ["description", "example"]])
+        if keys == ["type"] and isinstance(schema["type"], str) and schema["type"] in STRATEGIES_FOR_TYPE:
+            return cached_draw(STRATEGIES_FOR_TYPE[schema["type"]])
+        if keys == ["format", "type"]:
+            if schema["type"] != "string":
+                return cached_draw(STRATEGIES_FOR_TYPE[schema["type"]])
+            elif schema["format"] in FORMAT_STRATEGIES:
+                return cached_draw(FORMAT_STRATEGIES[schema["format"]])
+        if (keys == ["maxLength", "minLength", "type"] or keys == ["maxLength", "type"]) and schema["type"] == "string":
+            return cached_draw(st.text(min_size=schema.get("minLength", 0), max_size=schema["maxLength"]))
+        if (
+            keys == ["properties", "required", "type"]
+            or keys == ["properties", "required"]
+            or keys == ["properties", "type"]
+            or keys == ["properties"]
+        ):
+            obj = {}
+            for key, sub_schema in schema["properties"].items():
+                if isinstance(sub_schema, dict) and "const" in sub_schema:
+                    obj[key] = sub_schema["const"]
+                else:
+                    obj[key] = self.generate_from_schema(sub_schema)
+            return obj
+        if (
+            keys == ["maximum", "minimum", "type"] or keys == ["maximum", "type"] or keys == ["minimum", "type"]
+        ) and schema["type"] == "integer":
+            return cached_draw(st.integers(min_value=schema.get("minimum"), max_value=schema.get("maximum")))
+        if "enum" in schema:
+            return cached_draw(st.sampled_from(schema["enum"]))
+        if "pattern" in schema:
+            pattern = schema["pattern"]
+            try:
+                re.compile(pattern)
+            except re.error:
+                raise Unsatisfiable from None
+            return cached_draw(st.from_regex(pattern))
+        if (keys == ["items", "type"] or keys == ["items", "minItems", "type"]) and isinstance(schema["items"], dict):
+            items = schema["items"]
+            min_items = schema.get("minItems", 0)
+            if "enum" in items:
+                return cached_draw(st.lists(st.sampled_from(items["enum"]), min_size=min_items))
+            sub_keys = sorted([k for k in items if not k.startswith("x-") and k not in ["description", "example"]])
+            if sub_keys == ["type"] and items["type"] == "string":
+                return cached_draw(st.lists(st.text(), min_size=min_items))
+            if (
+                sub_keys == ["properties", "required", "type"]
+                or sub_keys == ["properties", "type"]
+                or sub_keys == ["properties"]
+            ):
+                return cached_draw(
+                    st.lists(
+                        st.fixed_dictionaries(
+                            {key: from_schema(sub_schema) for key, sub_schema in items["properties"].items()}
+                        ),
+                        min_size=min_items,
+                    )
+                )
+
+        if keys == ["allOf"]:
+            schema = canonicalish(schema)
+            if isinstance(schema, dict) and "allOf" not in schema:
+                return self.generate_from_schema(schema)
+
         return self.generate_from(from_schema(schema))
 
 
 T = TypeVar("T")
 
 
-def _to_hashable_key(value: T) -> T | tuple[type, str]:
+if c_make_encoder is not None:
+    _iterencode = c_make_encoder(None, None, encode_basestring_ascii, None, ":", ",", True, False, False)
+else:
+    _iterencode = _make_iterencode(
+        None, None, encode_basestring_ascii, None, float.__repr__, ":", ",", True, False, True
+    )
+
+
+def _encode(o: Any) -> str:
+    return "".join(_iterencode(o, 0))
+
+
+def _to_hashable_key(value: T, _encode: Callable = _encode) -> T | tuple[type, str]:
     if isinstance(value, (dict, list)):
-        serialized = json.dumps(value, sort_keys=True)
+        serialized = _encode(value)
         return (type(value), serialized)
     return value
 
@@ -193,7 +314,7 @@ def cover_schema_iter(
     if DataGenerationMethod.negative in ctx.data_generation_methods:
         template = None
         for key, value in schema.items():
-            with _ignore_unfixable():
+            with _ignore_unfixable(), ctx.location(key):
                 if key == "enum":
                     yield from _negative_enum(ctx, value)
                 elif key == "const":
@@ -207,24 +328,35 @@ def cover_schema_iter(
                 elif key == "properties":
                     template = template or ctx.generate_from_schema(_get_template_schema(schema, "object"))
                     yield from _negative_properties(ctx, template, value)
+                elif key == "patternProperties":
+                    template = template or ctx.generate_from_schema(_get_template_schema(schema, "object"))
+                    yield from _negative_pattern_properties(ctx, template, value)
+                elif key == "items" and isinstance(value, dict):
+                    yield from _negative_items(ctx, value)
                 elif key == "pattern":
-                    yield from _negative_pattern(ctx, value)
+                    min_length = schema.get("minLength")
+                    max_length = schema.get("maxLength")
+                    yield from _negative_pattern(ctx, value, min_length=min_length, max_length=max_length)
                 elif key == "format" and ("string" in types or not types):
                     yield from _negative_format(ctx, schema, value)
                 elif key == "maximum":
                     next = value + 1
                     if next not in seen:
-                        yield NegativeValue(next, description="Value greater than maximum")
+                        yield NegativeValue(
+                            next, description="Value greater than maximum", location=ctx.current_location
+                        )
                         seen.add(next)
                 elif key == "minimum":
                     next = value - 1
                     if next not in seen:
-                        yield NegativeValue(next, description="Value smaller than minimum")
+                        yield NegativeValue(
+                            next, description="Value smaller than minimum", location=ctx.current_location
+                        )
                         seen.add(next)
                 elif key == "exclusiveMaximum" or key == "exclusiveMinimum" and value not in seen:
                     verb = "greater" if key == "exclusiveMaximum" else "smaller"
                     limit = "maximum" if key == "exclusiveMaximum" else "minimum"
-                    yield NegativeValue(value, description=f"Value {verb} than {limit}")
+                    yield NegativeValue(value, description=f"Value {verb} than {limit}", location=ctx.current_location)
                     seen.add(value)
                 elif key == "multipleOf":
                     for value_ in _negative_multiple_of(ctx, schema, value):
@@ -236,35 +368,59 @@ def cover_schema_iter(
                     with suppress(InvalidArgument):
                         min_length = max_length = value - 1
                         new_schema = {**schema, "minLength": min_length, "maxLength": max_length}
+                        new_schema.setdefault("type", "string")
                         if "pattern" in new_schema:
                             new_schema["pattern"] = update_quantifier(schema["pattern"], min_length, max_length)
-                        value = ctx.generate_from_schema(new_schema)
+                            if new_schema["pattern"] == schema["pattern"]:
+                                # Pattern wasn't updated, try to generate a valid value then shrink the string to the required length
+                                del new_schema["minLength"]
+                                del new_schema["maxLength"]
+                                value = ctx.generate_from_schema(new_schema)[:max_length]
+                            else:
+                                value = ctx.generate_from_schema(new_schema)
+                        else:
+                            value = ctx.generate_from_schema(new_schema)
                         k = _to_hashable_key(value)
                         if k not in seen:
-                            yield NegativeValue(value, description="String smaller than minLength")
+                            yield NegativeValue(
+                                value, description="String smaller than minLength", location=ctx.current_location
+                            )
                             seen.add(k)
                 elif key == "maxLength" and value < BUFFER_SIZE:
-                    with suppress(InvalidArgument, Unsatisfiable):
-                        min_length = value + 1
-                        max_length = value + 1
+                    try:
+                        min_length = max_length = value + 1
                         new_schema = {**schema, "minLength": min_length, "maxLength": max_length}
+                        new_schema.setdefault("type", "string")
                         if "pattern" in new_schema:
                             new_schema["pattern"] = update_quantifier(schema["pattern"], min_length, max_length)
-                        value = ctx.generate_from_schema(new_schema)
+                            if new_schema["pattern"] == schema["pattern"]:
+                                # Pattern wasn't updated, try to generate a valid value then extend the string to the required length
+                                del new_schema["minLength"]
+                                del new_schema["maxLength"]
+                                value = ctx.generate_from_schema(new_schema).ljust(max_length, "0")
+                            else:
+                                value = ctx.generate_from_schema(new_schema)
+                        else:
+                            value = ctx.generate_from_schema(new_schema)
                         k = _to_hashable_key(value)
                         if k not in seen:
-                            yield NegativeValue(value, description="String larger than maxLength")
+                            yield NegativeValue(
+                                value, description="String larger than maxLength", location=ctx.current_location
+                            )
                             seen.add(k)
+                    except (InvalidArgument, Unsatisfiable):
+                        pass
                 elif key == "uniqueItems" and value:
                     yield from _negative_unique_items(ctx, schema)
                 elif key == "required":
                     template = template or ctx.generate_from_schema(_get_template_schema(schema, "object"))
                     yield from _negative_required(ctx, template, value)
-                elif key == "additionalProperties" and not value:
+                elif key == "additionalProperties" and not value and "pattern" not in schema:
                     template = template or ctx.generate_from_schema(_get_template_schema(schema, "object"))
                     yield NegativeValue(
                         {**template, UNKNOWN_PROPERTY_KEY: UNKNOWN_PROPERTY_VALUE},
                         description="Object with unexpected properties",
+                        location=ctx.current_location,
                     )
                 elif key == "allOf":
                     nctx = ctx.with_negative()
@@ -277,8 +433,9 @@ def cover_schema_iter(
                 elif key == "anyOf" or key == "oneOf":
                     nctx = ctx.with_negative()
                     # NOTE: Other sub-schemas are not filtered out
-                    for sub_schema in value:
-                        yield from cover_schema_iter(nctx, sub_schema, seen)
+                    for idx, sub_schema in enumerate(value):
+                        with nctx.location(idx):
+                            yield from cover_schema_iter(nctx, sub_schema, seen)
 
 
 def _get_properties(schema: dict | bool) -> dict | bool:
@@ -291,6 +448,9 @@ 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)
+        update_pattern_in_schema(_schema)
+        return _schema
     return schema
 
 
@@ -581,7 +741,7 @@ def _negative_enum(ctx: CoverageContext, value: list) -> Generator[GeneratedValu
 
     strategy = JSON_STRATEGY.filter(is_not_in_value)
     # The exact negative value is not important here
-    yield NegativeValue(ctx.generate_from(strategy), description="Invalid enum value")
+    yield NegativeValue(ctx.generate_from(strategy), description="Invalid enum value", location=ctx.current_location)
 
 
 def _negative_properties(
@@ -589,21 +749,63 @@ def _negative_properties(
 ) -> Generator[GeneratedValue, None, None]:
     nctx = ctx.with_negative()
     for key, sub_schema in properties.items():
-        for value in cover_schema_iter(nctx, sub_schema):
-            yield NegativeValue(
-                {**template, key: value.value},
-                description=f"Object with invalid '{key}' value: {value.description}",
-            )
+        with nctx.location(key):
+            for value in cover_schema_iter(nctx, sub_schema):
+                yield NegativeValue(
+                    {**template, key: value.value},
+                    description=f"Object with invalid '{key}' value: {value.description}",
+                    location=nctx.current_location,
+                )
+
+
+def _negative_pattern_properties(
+    ctx: CoverageContext, template: dict, pattern_properties: dict
+) -> Generator[GeneratedValue, None, None]:
+    nctx = ctx.with_negative()
+    for pattern, sub_schema in pattern_properties.items():
+        try:
+            key = ctx.generate_from(st.from_regex(pattern))
+        except re.error:
+            continue
+        with nctx.location(pattern):
+            for value in cover_schema_iter(nctx, sub_schema):
+                yield NegativeValue(
+                    {**template, key: value.value},
+                    description=f"Object with invalid pattern key '{key}' ('{pattern}') value: {value.description}",
+                    location=nctx.current_location,
+                )
+
 
+def _negative_items(ctx: CoverageContext, schema: dict[str, Any] | bool) -> Generator[GeneratedValue, None, None]:
+    """Arrays not matching the schema."""
+    nctx = ctx.with_negative()
+    for value in cover_schema_iter(nctx, schema):
+        yield NegativeValue(
+            [value.value],
+            description=f"Array with invalid items: {value.description}",
+            location=nctx.current_location,
+        )
 
-def _not_matching_pattern(value: str, pattern: str) -> bool:
-    return re.search(pattern, value) is None
 
+def _not_matching_pattern(value: str, pattern: re.Pattern) -> bool:
+    return pattern.search(value) is None
 
-def _negative_pattern(ctx: CoverageContext, pattern: str) -> Generator[GeneratedValue, None, None]:
+
+def _negative_pattern(
+    ctx: CoverageContext, pattern: str, min_length: int | None = None, max_length: int | None = None
+) -> Generator[GeneratedValue, None, None]:
+    try:
+        compiled = re.compile(pattern)
+    except re.error:
+        return
     yield NegativeValue(
-        ctx.generate_from(st.text().filter(partial(_not_matching_pattern, pattern=pattern))),
+        ctx.generate_from(
+            st.text(min_size=min_length or 0, max_size=max_length).filter(
+                partial(_not_matching_pattern, pattern=compiled)
+            )
+        ),
         description=f"Value not matching the '{pattern}' pattern",
+        location=ctx.current_location,
     )
 
 
@@ -617,12 +819,13 @@ def _negative_multiple_of(
     yield NegativeValue(
         ctx.generate_from_schema(_with_negated_key(schema, "multipleOf", multiple_of)),
         description=f"Non-multiple of {multiple_of}",
+        location=ctx.current_location,
     )
 
 
 def _negative_unique_items(ctx: CoverageContext, schema: dict) -> Generator[GeneratedValue, None, None]:
     unique = ctx.generate_from_schema({**schema, "type": "array", "minItems": 1, "maxItems": 1})
-    yield NegativeValue(unique + unique, description="Non-unique items")
+    yield NegativeValue(unique + unique, description="Non-unique items", location=ctx.current_location)
 
 
 def _negative_required(
@@ -632,6 +835,7 @@ def _negative_required(
         yield NegativeValue(
             {k: v for k, v in template.items() if k != key},
             description=f"Missing required property: {key}",
+            location=ctx.current_location,
         )
 
 
@@ -653,7 +857,11 @@ def _negative_format(ctx: CoverageContext, schema: dict, format: str) -> Generat
             strategy = strategy.filter(_is_invalid_hostname)
         else:
             strategy = strategy.filter(functools.partial(_is_invalid_format, format=format))
-    yield NegativeValue(ctx.generate_from(strategy), description=f"Value not matching the '{format}' format")
+    yield NegativeValue(
+        ctx.generate_from(strategy),
+        description=f"Value not matching the '{format}' format",
+        location=ctx.current_location,
+    )
 
 
 def _is_non_integer_float(x: float) -> bool:
@@ -661,31 +869,21 @@ def _is_non_integer_float(x: float) -> bool:
 
 
 def _negative_type(ctx: CoverageContext, seen: set, ty: str | list[str]) -> Generator[GeneratedValue, None, None]:
-    strategies = {
-        "integer": st.integers(),
-        "number": NUMERIC_STRATEGY,
-        "boolean": st.booleans(),
-        "null": st.none(),
-        "string": st.text(),
-        "array": ARRAY_STRATEGY,
-        "object": OBJECT_STRATEGY,
-    }
     if isinstance(ty, str):
         types = [ty]
     else:
         types = ty
-    for ty_ in types:
-        strategies.pop(ty_)
+    strategies = {ty: strategy for ty, strategy in STRATEGIES_FOR_TYPE.items() if ty not in types}
     if "number" in types:
         del strategies["integer"]
     if "integer" in types:
         strategies["number"] = FLOAT_STRATEGY.filter(_is_non_integer_float)
-    for strat in strategies.values():
-        value = ctx.generate_from(strat)
+    for strategy in strategies.values():
+        value = ctx.generate_from(strategy)
         hashed = _to_hashable_key(value)
         if hashed in seen:
             continue
-        yield NegativeValue(value, description="Incorrect type")
+        yield NegativeValue(value, description="Incorrect type", location=ctx.current_location)
         seen.add(hashed)
 
 

schemathesis/internal/checks.py

@@ -9,6 +9,7 @@ if TYPE_CHECKING:
     from requests.auth import HTTPDigestAuth
     from requests.structures import CaseInsensitiveDict
 
+    from .._override import CaseOverride
     from ..models import Case
     from ..transports.responses import GenericResponse
     from ..types import RawAuth
@@ -41,8 +42,9 @@ class CheckContext:
     Provides access to broader test execution data beyond individual test cases.
     """
 
-    auth: HTTPDigestAuth | RawAuth | None = None
-    headers: CaseInsensitiveDict | None = None
+    override: CaseOverride | None
+    auth: HTTPDigestAuth | RawAuth | None
+    headers: CaseInsensitiveDict | None
     config: CheckConfig = field(default_factory=CheckConfig)
 
 

schemathesis/internal/diff.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from typing import Any, Mapping
+
+
+def diff(left: Mapping[str, Any], right: Mapping[str, Any]) -> dict[str, Any]:
+    """Calculate the difference between two dictionaries."""
+    diff = {}
+    for key, value in right.items():
+        if key not in left or left[key] != value:
+            diff[key] = value
+    for key in left:
+        if key not in right:
+            diff[key] = None  # Mark deleted items as None
+    return diff