schemathesis 3.39.15__py3-none-any.whl → 4.0.0__py3-none-any.whl

schemathesis/specs/openapi/negative/mutations.py

@@ -11,7 +11,8 @@ from hypothesis import reject
 from hypothesis import strategies as st
 from hypothesis.strategies._internal.featureflags import FeatureStrategy
 
-from ....internal.copy import fast_deepcopy
+from schemathesis.core.transforms import deepclone
+
 from ..utils import get_type, is_header_location
 from .types import Draw, Schema
 from .utils import can_negate
@@ -19,7 +20,7 @@ from .utils import can_negate
 T = TypeVar("T")
 
 
-class MutationResult(enum.Enum):
+class MutationResult(int, enum.Enum):
     """The result of applying some mutation to some schema.
 
     Failing to mutate something means that by applying some mutation, it is not possible to change
@@ -111,7 +112,7 @@ class MutationContext:
             # Body can be of any type and does not have any specific type semantic.
             mutations = draw(ordered(get_mutations(draw, self.keywords)))
         # Deep copy all keywords to avoid modifying the original schema
-        new_schema = fast_deepcopy(self.keywords)
+        new_schema = deepclone(self.keywords)
         enabled_mutations = draw(st.shared(FeatureStrategy(), key="mutations"))  # type: ignore
         # Always apply at least one mutation, otherwise everything is rejected, and we'd like to avoid it
         # for performance reasons
@@ -401,8 +402,8 @@ def negate_constraints(context: MutationContext, draw: Draw, schema: Schema) ->
                 if key in DEPENDENCIES:
                     # If this keyword has a dependency, then it should be also negated
                     dependency = DEPENDENCIES[key]
-                    if dependency not in negated:
-                        negated[dependency] = copied[dependency]  # Assuming the schema is valid
+                    if dependency not in negated and dependency in copied:
+                        negated[dependency] = copied[dependency]
         else:
             schema[key] = value
     if is_negated:

schemathesis/specs/openapi/parameters.py

@@ -4,12 +4,13 @@ import json
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, ClassVar, Iterable
 
-from ...exceptions import OperationSchemaError
-from ...parameters import Parameter
+from schemathesis.core.errors import InvalidSchema
+from schemathesis.schemas import Parameter
+
 from .converter import to_json_schema_recursive
 
 if TYPE_CHECKING:
-    from ...models import APIOperation
+    from ...schemas import APIOperation
 
 
 @dataclass(eq=False)
@@ -22,6 +23,7 @@ class OpenAPIParameter(Parameter):
     supported_jsonschema_keywords: ClassVar[tuple[str, ...]]
 
     def _repr_pretty_(self, *args: Any, **kwargs: Any) -> None: ...
+
     @property
     def description(self) -> str | None:
         """A brief parameter description."""
@@ -312,9 +314,6 @@ def parameters_to_json_schema(
 ) -> dict[str, Any]:
     """Create an "object" JSON schema from a list of Open API parameters.
 
-    :param List[OpenAPIParameter] parameters: A list of Open API parameters related to the same location. All of
-        them are expected to have the same "in" value.
-
     For each input parameter, there will be a property in the output schema.
 
     This:
@@ -371,13 +370,12 @@ def get_parameter_schema(operation: APIOperation, data: dict[str, Any]) -> dict[
     # In Open API 3.0, there could be "schema" or "content" field. They are mutually exclusive.
     if "schema" in data:
         if not isinstance(data["schema"], dict):
-            raise OperationSchemaError(
+            raise InvalidSchema(
                 INVALID_SCHEMA_MESSAGE.format(
                     location=data.get("in", ""), name=data.get("name", "<UNKNOWN>"), schema=data["schema"]
                 ),
                 path=operation.path,
                 method=operation.method,
-                full_path=operation.full_path,
             )
         return data["schema"]
     # https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.3.md#fixed-fields-10
@@ -385,11 +383,10 @@ def get_parameter_schema(operation: APIOperation, data: dict[str, Any]) -> dict[
     try:
         content = data["content"]
     except KeyError as exc:
-        raise OperationSchemaError(
+        raise InvalidSchema(
             MISSING_SCHEMA_OR_CONTENT_MESSAGE.format(location=data.get("in", ""), name=data.get("name", "<UNKNOWN>")),
             path=operation.path,
             method=operation.method,
-            full_path=operation.full_path,
         ) from exc
     options = iter(content.values())
     media_type_object = next(options)

schemathesis/specs/openapi/patterns.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import re
 from functools import lru_cache
 
-from ...exceptions import InternalError
+from schemathesis.core.errors import InternalError
 
 try:  # pragma: no cover
     import re._constants as sre
@@ -19,11 +19,12 @@ if hasattr(sre, "POSSESSIVE_REPEAT"):
 else:
     REPEATS = (sre.MIN_REPEAT, sre.MAX_REPEAT)
 LITERAL = sre.LITERAL
+NOT_LITERAL = sre.NOT_LITERAL
 IN = sre.IN
 MAXREPEAT = sre_parse.MAXREPEAT
 
 
-@lru_cache()
+@lru_cache
 def update_quantifier(pattern: str, min_length: int | None, max_length: int | None) -> str:
     """Update the quantifier of a regular expression based on given min and max lengths."""
     if not pattern or (min_length in (None, 0) and max_length is None):
@@ -69,13 +70,18 @@ def _handle_parsed_pattern(parsed: list, pattern: str, min_length: int | None, m
         trailing_anchor_length = _get_anchor_length(parsed[2][1])
         leading_anchor = pattern[:leading_anchor_length]
         trailing_anchor = pattern[-trailing_anchor_length:]
-        return (
-            leading_anchor
-            + _update_quantifier(
-                op, value, pattern[leading_anchor_length:-trailing_anchor_length], min_length, max_length
-            )
-            + trailing_anchor
-        )
+        # Special case for patterns canonicalisation. Some frameworks generate `\\w\\W` instead of `.`
+        # Such patterns lead to significantly slower data generation
+        if op == sre.IN and _matches_anything(value):
+            op = sre.ANY
+            value = None
+            inner_pattern = "."
+        elif op in REPEATS and len(value[2]) == 1 and value[2][0][0] == sre.IN and _matches_anything(value[2][0][1]):
+            value = (value[0], value[1], [(sre.ANY, None)], *value[3:])
+            inner_pattern = "."
+        else:
+            inner_pattern = pattern[leading_anchor_length:-trailing_anchor_length]
+        return leading_anchor + _update_quantifier(op, value, inner_pattern, min_length, max_length) + trailing_anchor
     elif (
         len(parsed) > 3
         and parsed[0][0] == ANCHOR
@@ -86,6 +92,19 @@ def _handle_parsed_pattern(parsed: list, pattern: str, min_length: int | None, m
     return pattern
 
 
+def _matches_anything(value: list) -> bool:
+    """Check if the given pattern is equivalent to '.' (match any character)."""
+    # Common forms: [\w\W], [\s\S], etc.
+    return value in (
+        [(sre.CATEGORY, sre.CATEGORY_WORD), (sre.CATEGORY, sre.CATEGORY_NOT_WORD)],
+        [(sre.CATEGORY, sre.CATEGORY_SPACE), (sre.CATEGORY, sre.CATEGORY_NOT_SPACE)],
+        [(sre.CATEGORY, sre.CATEGORY_DIGIT), (sre.CATEGORY, sre.CATEGORY_NOT_DIGIT)],
+        [(sre.CATEGORY, sre.CATEGORY_NOT_WORD), (sre.CATEGORY, sre.CATEGORY_WORD)],
+        [(sre.CATEGORY, sre.CATEGORY_NOT_SPACE), (sre.CATEGORY, sre.CATEGORY_SPACE)],
+        [(sre.CATEGORY, sre.CATEGORY_NOT_DIGIT), (sre.CATEGORY, sre.CATEGORY_DIGIT)],
+    )
+
+
 def _handle_anchored_pattern(parsed: list, pattern: str, min_length: int | None, max_length: int | None) -> str:
     """Update regex pattern with multiple quantified patterns to satisfy length constraints."""
     # Extract anchors
@@ -96,8 +115,20 @@ def _handle_anchored_pattern(parsed: list, pattern: str, min_length: int | None,
 
     pattern_parts = parsed[1:-1]
 
+    # Calculate total fixed length and per-repetition lengths
+    fixed_length = 0
+    quantifier_bounds = []
+    repetition_lengths = []
+
+    for op, value in pattern_parts:
+        if op in (LITERAL, NOT_LITERAL):
+            fixed_length += 1
+        elif op in REPEATS:
+            min_repeat, max_repeat, subpattern = value
+            quantifier_bounds.append((min_repeat, max_repeat))
+            repetition_lengths.append(_calculate_min_repetition_length(subpattern))
+
     # Adjust length constraints by subtracting fixed literals length
-    fixed_length = sum(1 for op, _ in pattern_parts if op == LITERAL)
     if min_length is not None:
         min_length -= fixed_length
         if min_length < 0:
@@ -107,13 +138,10 @@ def _handle_anchored_pattern(parsed: list, pattern: str, min_length: int | None,
         if max_length < 0:
             return pattern
 
-    # Extract only min/max bounds from quantified parts
-    quantifier_bounds = [value[:2] for op, value in pattern_parts if op in REPEATS]
-
     if not quantifier_bounds:
         return pattern
 
-    length_distribution = _distribute_length_constraints(quantifier_bounds, min_length, max_length)
+    length_distribution = _distribute_length_constraints(quantifier_bounds, repetition_lengths, min_length, max_length)
     if not length_distribution:
         return pattern
 
@@ -194,7 +222,7 @@ def _find_quantified_end(pattern: str, start: int) -> int:
 
 
 def _distribute_length_constraints(
-    bounds: list[tuple[int, int]], min_length: int | None, max_length: int | None
+    bounds: list[tuple[int, int]], repetition_lengths: list[int], min_length: int | None, max_length: int | None
 ) -> list[tuple[int, int]] | None:
     """Distribute length constraints among quantified pattern parts."""
     # Handle exact length case with dynamic programming
@@ -210,18 +238,22 @@ def _distribute_length_constraints(
             if pos == len(bounds):
                 return [()] if remaining == 0 else None
 
-            max_len: int
-            min_len, max_len = bounds[pos]
-            if max_len == MAXREPEAT:
-                max_len = remaining + 1
-            else:
-                max_len += 1
+            max_repeat: int
+            min_repeat, max_repeat = bounds[pos]
+            repeat_length = repetition_lengths[pos]
+
+            if max_repeat == MAXREPEAT:
+                max_repeat = remaining // repeat_length + 1 if repeat_length > 0 else remaining + 1
 
             # Try each possible length for current quantifier
-            for length in range(min_len, max_len):
-                rest = find_valid_combination(pos + 1, remaining - length)
+            for repeat_count in range(min_repeat, max_repeat + 1):
+                used_length = repeat_count * repeat_length
+                if used_length > remaining:
+                    break
+
+                rest = find_valid_combination(pos + 1, remaining - used_length)
                 if rest is not None:
-                    dp[(pos, remaining)] = [(length,) + r for r in rest]
+                    dp[(pos, remaining)] = [(repeat_count,) + r for r in rest]
                     return dp[(pos, remaining)]
 
             dp[(pos, remaining)] = None
@@ -262,6 +294,22 @@ def _distribute_length_constraints(
     return result
 
 
+def _calculate_min_repetition_length(subpattern: list) -> int:
+    """Calculate minimum length contribution per repetition of a quantified group."""
+    total = 0
+    for op, value in subpattern:
+        if op in [LITERAL, NOT_LITERAL, IN, sre.ANY]:
+            total += 1
+        elif op == sre.SUBPATTERN:
+            _, _, _, inner_pattern = value
+            total += _calculate_min_repetition_length(inner_pattern)
+        elif op in REPEATS:
+            min_repeat, _, inner_pattern = value
+            inner_min = _calculate_min_repetition_length(inner_pattern)
+            total += min_repeat * inner_min
+    return total
+
+
 def _get_anchor_length(node_type: int) -> int:
     """Determine the length of the anchor based on its type."""
     if node_type in {sre.AT_BEGINNING_STRING, sre.AT_END_STRING, sre.AT_BOUNDARY, sre.AT_NON_BOUNDARY}:
@@ -269,15 +317,28 @@ def _get_anchor_length(node_type: int) -> int:
     return 1  # ^ or $ or their multiline/locale/unicode variants
 
 
-def _update_quantifier(op: int, value: tuple, pattern: str, min_length: int | None, max_length: int | None) -> str:
+def _update_quantifier(
+    op: int, value: tuple | None, pattern: str, min_length: int | None, max_length: int | None
+) -> str:
     """Update the quantifier based on the operation type and given constraints."""
-    if op in REPEATS:
+    if op in REPEATS and value is not None:
         return _handle_repeat_quantifier(value, pattern, min_length, max_length)
-    if op in (LITERAL, IN) and max_length != 0:
+    if op in (LITERAL, NOT_LITERAL, IN) and max_length != 0:
         return _handle_literal_or_in_quantifier(pattern, min_length, max_length)
+    if op == sre.ANY and value is None:
+        # Equivalent to `.` which is in turn is the same as `.{1}`
+        return _handle_repeat_quantifier(
+            SINGLE_ANY,
+            pattern,
+            min_length,
+            max_length,
+        )
     return pattern
 
 
+SINGLE_ANY = sre_parse.parse(".{1}")[0][1]
+
+
 def _handle_repeat_quantifier(
     value: tuple[int, int, tuple], pattern: str, min_length: int | None, max_length: int | None
 ) -> str:
@@ -324,10 +385,12 @@ def _build_size(min_repeat: int, max_repeat: int, min_length: int | None, max_le
 def _strip_quantifier(pattern: str) -> str:
     """Remove quantifier from the pattern."""
     # Lazy & posessive quantifiers
-    if pattern.endswith(("*?", "+?", "??", "*+", "?+", "++")):
-        return pattern[:-2]
-    if pattern.endswith(("?", "*", "+")):
-        pattern = pattern[:-1]
+    for marker in ("*?", "+?", "??", "*+", "?+", "++"):
+        if pattern.endswith(marker) and not pattern.endswith(rf"\{marker}"):
+            return pattern[:-2]
+    for marker in ("?", "*", "+"):
+        if pattern.endswith(marker) and not pattern.endswith(rf"\{marker}"):
+            pattern = pattern[:-1]
     if pattern.endswith("}") and "{" in pattern:
         # Find the start of the exact quantifier and drop everything since that index
         idx = pattern.rfind("{")

schemathesis/specs/openapi/references.py

@@ -1,18 +1,17 @@
 from __future__ import annotations
 
 import sys
-from dataclasses import dataclass
 from functools import lru_cache
 from typing import Any, Callable, Dict, Union, overload
 from urllib.request import urlopen
 
-import jsonschema
 import requests
-from jsonschema.exceptions import RefResolutionError
 
-from ...constants import DEFAULT_RESPONSE_TIMEOUT
-from ...internal.copy import fast_deepcopy
-from ...loaders import load_yaml
+from schemathesis.core.compat import RefResolutionError, RefResolver
+from schemathesis.core.deserialization import deserialize_yaml
+from schemathesis.core.transforms import deepclone
+from schemathesis.core.transport import DEFAULT_RESPONSE_TIMEOUT
+
 from .constants import ALL_KEYWORDS
 from .converter import to_json_schema_recursive
 from .utils import get_type
@@ -24,7 +23,7 @@ RECURSION_DEPTH_LIMIT = 100
 def load_file_impl(location: str, opener: Callable) -> dict[str, Any]:
     """Load a schema from the given file."""
     with opener(location) as fd:
-        return load_yaml(fd)
+        return deserialize_yaml(fd)
 
 
 @lru_cache
@@ -41,14 +40,14 @@ def load_file_uri(location: str) -> dict[str, Any]:
 
 def load_remote_uri(uri: str) -> Any:
     """Load the resource and parse it as YAML / JSON."""
-    response = requests.get(uri, timeout=DEFAULT_RESPONSE_TIMEOUT / 1000)
-    return load_yaml(response.content)
+    response = requests.get(uri, timeout=DEFAULT_RESPONSE_TIMEOUT)
+    return deserialize_yaml(response.content)
 
 
 JSONType = Union[None, bool, float, str, list, Dict[str, Any]]
 
 
-class InliningResolver(jsonschema.RefResolver):
+class InliningResolver(RefResolver):
     """Inlines resolved schemas."""
 
     def __init__(self, *args: Any, **kwargs: Any) -> None:
@@ -75,12 +74,10 @@ class InliningResolver(jsonschema.RefResolver):
                 raise
 
     @overload
-    def resolve_all(self, item: dict[str, Any], recursion_level: int = 0) -> dict[str, Any]:
-        pass
+    def resolve_all(self, item: dict[str, Any], recursion_level: int = 0) -> dict[str, Any]: ...
 
     @overload
-    def resolve_all(self, item: list, recursion_level: int = 0) -> list:
-        pass
+    def resolve_all(self, item: list, recursion_level: int = 0) -> list: ...
 
     def resolve_all(self, item: JSONType, recursion_level: int = 0) -> JSONType:
         """Recursively resolve all references in the given object."""
@@ -95,7 +92,7 @@ class InliningResolver(jsonschema.RefResolver):
                     # In other cases, this method create new objects for mutable types (dict & list)
                     next_recursion_level = recursion_level + 1
                     if next_recursion_level > RECURSION_DEPTH_LIMIT:
-                        copied = fast_deepcopy(resolved)
+                        copied = deepclone(resolved)
                         remove_optional_references(copied)
                         return copied
                     return resolve(resolved, next_recursion_level)
@@ -238,41 +235,3 @@ def remove_optional_references(schema: dict[str, Any]) -> None:
                 clean_additional_properties(definition)
             for k in on_single_item_combinators(definition):
                 del definition[k]
-
-
-@dataclass
-class Unresolvable:
-    pass
-
-
-UNRESOLVABLE = Unresolvable()
-
-
-def resolve_pointer(document: Any, pointer: str) -> dict | list | str | int | float | None | Unresolvable:
-    """Implementation is adapted from Rust's `serde-json` crate.
-
-    Ref: https://github.com/serde-rs/json/blob/master/src/value/mod.rs#L751
-    """
-    if not pointer:
-        return document
-    if not pointer.startswith("/"):
-        return UNRESOLVABLE
-
-    def replace(value: str) -> str:
-        return value.replace("~1", "/").replace("~0", "~")
-
-    tokens = map(replace, pointer.split("/")[1:])
-    target = document
-    for token in tokens:
-        if isinstance(target, dict):
-            target = target.get(token, UNRESOLVABLE)
-            if target is UNRESOLVABLE:
-                return UNRESOLVABLE
-        elif isinstance(target, list):
-            try:
-                target = target[int(token)]
-            except IndexError:
-                return UNRESOLVABLE
-        else:
-            return UNRESOLVABLE
-    return target