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

schemathesis/failures.py

@@ -1,10 +1,14 @@
 from __future__ import annotations
+
 import textwrap
 from dataclasses import dataclass
-from json import JSONDecodeError
-from typing import Any, TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
+
+from schemathesis.internal.output import OutputConfig
 
 if TYPE_CHECKING:
+    from json import JSONDecodeError
+
     from graphql.error import GraphQLFormattedError
     from jsonschema import ValidationError
 
@@ -41,16 +45,27 @@ class ValidationErrorContext(FailureContext):
         return ("/".join(map(str, self.schema_path)),)
 
     @classmethod
-    def from_exception(cls, exc: ValidationError) -> ValidationErrorContext:
-        from .exceptions import truncated_json
-
-        schema = textwrap.indent(truncated_json(exc.schema, max_lines=20), prefix="    ")
-        value = textwrap.indent(truncated_json(exc.instance, max_lines=20), prefix="    ")
-        message = f"{exc.message}\n\nSchema:\n\n{schema}\n\nValue:\n\n{value}"
+    def from_exception(
+        cls, exc: ValidationError, *, output_config: OutputConfig | None = None
+    ) -> ValidationErrorContext:
+        from .internal.output import truncate_json
+
+        output_config = OutputConfig.from_parent(output_config, max_lines=20)
+        schema = textwrap.indent(truncate_json(exc.schema, config=output_config), prefix="    ")
+        value = textwrap.indent(truncate_json(exc.instance, config=output_config), prefix="    ")
+        schema_path = list(exc.absolute_schema_path)
+        if len(schema_path) > 1:
+            # Exclude the last segment, which is already in the schema
+            schema_title = "Schema at "
+            for segment in schema_path[:-1]:
+                schema_title += f"/{segment}"
+        else:
+            schema_title = "Schema"
+        message = f"{exc.message}\n\n{schema_title}:\n\n{schema}\n\nValue:\n\n{value}"
         return cls(
             message=message,
             validation_message=exc.message,
-            schema_path=list(exc.absolute_schema_path),
+            schema_path=schema_path,
             schema=exc.schema,
             instance_path=list(exc.absolute_path),
             instance=exc.instance,
@@ -117,6 +132,59 @@ class UndefinedContentType(FailureContext):
     type: str = "undefined_content_type"
 
 
+@dataclass(repr=False)
+class AcceptedNegativeData(FailureContext):
+    """Response with negative data was accepted."""
+
+    message: str
+    status_code: int
+    allowed_statuses: list[str]
+    title: str = "Accepted negative data"
+    type: str = "accepted_negative_data"
+
+
+@dataclass(repr=False)
+class RejectedPositiveData(FailureContext):
+    """Response with positive data was rejected."""
+
+    message: str
+    status_code: int
+    allowed_statuses: list[str]
+    title: str = "Rejected positive data"
+    type: str = "rejected_positive_data"
+
+
+@dataclass(repr=False)
+class UseAfterFree(FailureContext):
+    """Resource was used after a successful DELETE operation on it."""
+
+    message: str
+    free: str
+    usage: str
+    title: str = "Use after free"
+    type: str = "use_after_free"
+
+
+@dataclass(repr=False)
+class EnsureResourceAvailability(FailureContext):
+    """Resource is not available immediately after creation."""
+
+    message: str
+    created_with: str
+    not_available_with: str
+    title: str = "Resource is not available after creation"
+    type: str = "ensure_resource_availability"
+
+
+@dataclass(repr=False)
+class IgnoredAuth(FailureContext):
+    """The API operation does not check the specified authentication."""
+
+    message: str
+    title: str = "Authentication declared but not enforced for this operation"
+    type: str = "ignored_auth"
+
+
 @dataclass(repr=False)
 class UndefinedStatusCode(FailureContext):
     """Response has a status code that is not defined in the schema."""

schemathesis/filters.py

@@ -1,12 +1,17 @@
 """Filtering system that allows users to filter API operations based on certain criteria."""
+
 from __future__ import annotations
+
+import json
 import re
 from dataclasses import dataclass, field
 from functools import partial
 from types import SimpleNamespace
-from typing import TYPE_CHECKING, Callable, List, Union, Protocol
+from typing import TYPE_CHECKING, Any, Callable, List, Protocol, Union
 
 from .exceptions import UsageError
+from .types import Filter as FilterType
+from .types import NotSet
 
 if TYPE_CHECKING:
     from .models import APIOperation
@@ -49,16 +54,21 @@ class Matcher:
             func = partial(by_value_list, attribute=attribute, expected=expected)
         else:
             func = partial(by_value, attribute=attribute, expected=expected)
-        label = f"{attribute}={repr(expected)}"
+        label = f"{attribute}={expected!r}"
         return cls(func, label=label, _hash=hash(label))
 
     @classmethod
     def for_regex(cls, attribute: str, regex: RegexValue) -> Matcher:
         """Matcher that checks whether the specified attribute has the provided regex."""
         if isinstance(regex, str):
-            regex = re.compile(regex)
+            flags: re.RegexFlag | int
+            if attribute == "method":
+                flags = re.IGNORECASE
+            else:
+                flags = 0
+            regex = re.compile(regex, flags=flags)
         func = partial(by_regex, attribute=attribute, regex=regex)
-        label = f"{attribute}_regex={repr(regex)}"
+        label = f"{attribute}_regex={regex!r}"
         return cls(func, label=label, _hash=hash(label))
 
     def match(self, ctx: HasAPIOperation) -> bool:
@@ -69,6 +79,8 @@ class Matcher:
 def get_operation_attribute(operation: APIOperation, attribute: str) -> str | list[str] | None:
     if attribute == "tag":
         return operation.tags
+    if attribute == "operation_id":
+        return operation.definition.raw.get("operationId")
     # Just uppercase `method`
     value = getattr(operation, attribute)
     if attribute == "method":
@@ -99,8 +111,8 @@ def by_regex(ctx: HasAPIOperation, attribute: str, regex: re.Pattern) -> bool:
     if value is None:
         return False
     if isinstance(value, list):
-        return any(bool(regex.match(entry)) for entry in value)
-    return bool(regex.match(value))
+        return any(bool(regex.search(entry)) for entry in value)
+    return bool(regex.search(value))
 
 
 @dataclass(repr=False, frozen=True)
@@ -109,6 +121,8 @@ class Filter:
 
     matchers: tuple[Matcher, ...]
 
+    __slots__ = ("matchers",)
+
     def __repr__(self) -> str:
         inner = " && ".join(matcher.label for matcher in self.matchers)
         return f"<{self.__class__.__name__}: [{inner}]>"
@@ -125,8 +139,34 @@ class Filter:
 class FilterSet:
     """Combines multiple filters to apply inclusion and exclusion rules on API operations."""
 
-    _includes: set[Filter] = field(default_factory=set)
-    _excludes: set[Filter] = field(default_factory=set)
+    _includes: set[Filter]
+    _excludes: set[Filter]
+
+    __slots__ = ("_includes", "_excludes")
+
+    def __init__(self, _includes: set[Filter] | None = None, _excludes: set[Filter] | None = None) -> None:
+        self._includes = _includes or set()
+        self._excludes = _excludes or set()
+
+    def clone(self) -> FilterSet:
+        return FilterSet(_includes=self._includes.copy(), _excludes=self._excludes.copy())
+
+    def merge(self, other: FilterSet) -> FilterSet:
+        def _merge(lhs: set[Filter], rhs: set[Filter]) -> set[Filter]:
+            result = lhs.copy()
+            for new in rhs:
+                for old in lhs:
+                    for new_matcher in new.matchers:
+                        for old_matcher in old.matchers:
+                            if "=" in new_matcher.label and "=" in old_matcher.label:
+                                if new_matcher.label.split("=")[0] == old_matcher.label.split("=")[0]:
+                                    result.remove(old)
+                result.add(new)
+            return result
+
+        return FilterSet(
+            _includes=_merge(self._includes, other._includes), _excludes=_merge(self._excludes, other._excludes)
+        )
 
     def apply_to(self, operations: list[APIOperation]) -> list[APIOperation]:
         """Get a filtered list of the given operations that match the filters."""
@@ -166,6 +206,8 @@ class FilterSet:
         path_regex: RegexValue | None = None,
         tag: FilterValue | None = None,
         tag_regex: RegexValue | None = None,
+        operation_id: FilterValue | None = None,
+        operation_id_regex: RegexValue | None = None,
     ) -> None:
         """Add a new INCLUDE filter."""
         self._add_filter(
@@ -179,6 +221,8 @@ class FilterSet:
             path_regex=path_regex,
             tag=tag,
             tag_regex=tag_regex,
+            operation_id=operation_id,
+            operation_id_regex=operation_id_regex,
         )
 
     def exclude(
@@ -193,6 +237,8 @@ class FilterSet:
         path_regex: RegexValue | None = None,
         tag: FilterValue | None = None,
         tag_regex: RegexValue | None = None,
+        operation_id: FilterValue | None = None,
+        operation_id_regex: RegexValue | None = None,
     ) -> None:
         """Add a new EXCLUDE filter."""
         self._add_filter(
@@ -206,6 +252,8 @@ class FilterSet:
             path_regex=path_regex,
             tag=tag,
             tag_regex=tag_regex,
+            operation_id=operation_id,
+            operation_id_regex=operation_id_regex,
         )
 
     def _add_filter(
@@ -221,6 +269,8 @@ class FilterSet:
         path_regex: RegexValue | None = None,
         tag: FilterValue | None = None,
         tag_regex: RegexValue | None = None,
+        operation_id: FilterValue | None = None,
+        operation_id_regex: RegexValue | None = None,
     ) -> None:
         matchers = []
         if func is not None:
@@ -230,6 +280,7 @@ class FilterSet:
             ("method", method, method_regex),
             ("path", path, path_regex),
             ("tag", tag, tag_regex),
+            ("operation_id", operation_id, operation_id_regex),
         ):
             if expected is not None and regex is not None:
                 # To match anything the regex should match the expected value, hence passing them together is useless
@@ -274,8 +325,12 @@ def attach_filter_chain(
         name_regex: str | None = None,
         method: FilterValue | None = None,
         method_regex: str | None = None,
+        tag: FilterValue | None = None,
+        tag_regex: RegexValue | None = None,
         path: FilterValue | None = None,
         path_regex: str | None = None,
+        operation_id: FilterValue | None = None,
+        operation_id_regex: RegexValue | None = None,
     ) -> Callable:
         __tracebackhide__ = True
         filter_func(
@@ -284,8 +339,12 @@ def attach_filter_chain(
             name_regex=name_regex,
             method=method,
             method_regex=method_regex,
+            tag=tag,
+            tag_regex=tag_regex,
             path=path,
             path_regex=path_regex,
+            operation_id=operation_id,
+            operation_id_regex=operation_id_regex,
         )
         return target
 
@@ -293,3 +352,121 @@ def attach_filter_chain(
     proxy.__name__ = attribute
 
     setattr(target, attribute, proxy)
+
+
+def is_deprecated(ctx: HasAPIOperation) -> bool:
+    return ctx.operation.definition.raw.get("deprecated") is True
+
+
+def filter_set_from_components(
+    *,
+    include: bool,
+    method: FilterType | None = None,
+    endpoint: FilterType | None = None,
+    tag: FilterType | None = None,
+    operation_id: FilterType | None = None,
+    skip_deprecated_operations: bool | None | NotSet = None,
+    parent: FilterSet | None = None,
+) -> FilterSet:
+    def _is_defined(x: FilterType | None) -> bool:
+        return x is not None and not isinstance(x, NotSet)
+
+    def _prepare_filter(filter_: FilterType | None) -> RegexValue | None:
+        if filter_ is None or isinstance(filter_, NotSet):
+            return None
+        if isinstance(filter_, str):
+            return filter_
+        return "|".join(f"({f})" for f in filter_)
+
+    new = FilterSet()
+
+    if _is_defined(method) or _is_defined(endpoint) or _is_defined(tag) or _is_defined(operation_id):
+        new._add_filter(
+            include,
+            method_regex=_prepare_filter(method),
+            path_regex=_prepare_filter(endpoint),
+            tag_regex=_prepare_filter(tag),
+            operation_id_regex=_prepare_filter(operation_id),
+        )
+    if skip_deprecated_operations is True and not any(
+        matcher.label == is_deprecated.__name__ for exclude_ in new._excludes for matcher in exclude_.matchers
+    ):
+        new.exclude(func=is_deprecated)
+    # Merge with the parent filter set
+    if parent is not None:
+        for include_ in parent._includes:
+            matchers = include_.matchers
+            ids = []
+            for idx, matcher in enumerate(matchers):
+                label = matcher.label
+                if (
+                    (not isinstance(method, NotSet) and label.startswith("method_regex="))
+                    or (not isinstance(endpoint, NotSet) and label.startswith("path_regex="))
+                    or (not isinstance(tag, NotSet) and matcher.label.startswith("tag_regex="))
+                    or (not isinstance(operation_id, NotSet) and matcher.label.startswith("operation_id_regex="))
+                ):
+                    ids.append(idx)
+            if ids:
+                matchers = tuple(matcher for idx, matcher in enumerate(matchers) if idx not in ids)
+            if matchers:
+                if new._includes:
+                    existing = new._includes.pop()
+                    matchers = existing.matchers + matchers
+                new._includes.add(Filter(matchers=matchers))
+        for exclude_ in parent._excludes:
+            matchers = exclude_.matchers
+            ids = []
+            for idx, matcher in enumerate(exclude_.matchers):
+                if skip_deprecated_operations is False and matcher.label == is_deprecated.__name__:
+                    ids.append(idx)
+            if ids:
+                matchers = tuple(matcher for idx, matcher in enumerate(matchers) if idx not in ids)
+            if matchers:
+                new._excludes.add(exclude_)
+    return new
+
+
+def parse_expression(expression: str) -> tuple[str, str, Any]:
+    expression = expression.strip()
+
+    # Find the operator
+    for op in ("==", "!="):
+        try:
+            pointer, value = expression.split(op, 1)
+            break
+        except ValueError:
+            continue
+    else:
+        raise ValueError(f"Invalid expression: {expression}")
+
+    pointer = pointer.strip()
+    value = value.strip()
+    if not pointer or not value:
+        raise ValueError(f"Invalid expression: {expression}")
+    # Parse the JSON value
+    try:
+        return pointer, op, json.loads(value)
+    except json.JSONDecodeError:
+        # If it's not valid JSON, treat it as a string
+        return pointer, op, value
+
+
+def expression_to_filter_function(expression: str) -> Callable[[HasAPIOperation], bool]:
+    from .specs.openapi.references import resolve_pointer
+
+    pointer, op, value = parse_expression(expression)
+
+    if op == "==":
+
+        def filter_function(ctx: HasAPIOperation) -> bool:
+            definition = ctx.operation.definition.resolved
+            resolved = resolve_pointer(definition, pointer)
+            return resolved == value
+    else:
+
+        def filter_function(ctx: HasAPIOperation) -> bool:
+            definition = ctx.operation.definition.resolved
+            resolved = resolve_pointer(definition, pointer)
+            return resolved != value
+
+    return filter_function

schemathesis/fixups/__init__.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 from typing import Iterable
 
 from . import fast_api, utf8_bom

schemathesis/fixups/fast_api.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
+
 from typing import Any
 
-from ..hooks import HookContext
+from ..hooks import HookContext, register, unregister
 from ..hooks import is_installed as global_is_installed
-from ..hooks import register, unregister
 from ..internal.jsonschema import traverse_schema
 
 

schemathesis/fixups/utf8_bom.py

@@ -1,9 +1,8 @@
 from typing import TYPE_CHECKING
 
 from ..constants import BOM_MARK
-from ..hooks import HookContext
+from ..hooks import HookContext, register, unregister
 from ..hooks import is_installed as global_is_installed
-from ..hooks import register, unregister
 
 if TYPE_CHECKING:
     from ..models import Case

schemathesis/generation/__init__.py

@@ -1,44 +1,15 @@
 from __future__ import annotations
-import random
-from dataclasses import dataclass
-from enum import Enum
-from typing import Union, Iterable
-
-
-class DataGenerationMethod(str, Enum):
-    """Defines what data Schemathesis generates for tests."""
-
-    # Generate data, that fits the API schema
-    positive = "positive"
-    # Doesn't fit the API schema
-    negative = "negative"
-
-    @classmethod
-    def default(cls) -> DataGenerationMethod:
-        return cls.positive
-
-    @classmethod
-    def all(cls) -> list[DataGenerationMethod]:
-        return list(DataGenerationMethod)
 
-    def as_short_name(self) -> str:
-        return {
-            DataGenerationMethod.positive: "P",
-            DataGenerationMethod.negative: "N",
-        }[self]
-
-    @property
-    def is_negative(self) -> bool:
-        return self == DataGenerationMethod.negative
+import random
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
 
-    @classmethod
-    def ensure_list(cls, value: DataGenerationMethodInput) -> list[DataGenerationMethod]:
-        if isinstance(value, DataGenerationMethod):
-            return [value]
-        return list(value)
+from ._hypothesis import add_single_example, combine_strategies, get_single_example
+from ._methods import DataGenerationMethod, DataGenerationMethodInput
 
+if TYPE_CHECKING:
+    from hypothesis.strategies import SearchStrategy
 
-DataGenerationMethodInput = Union[DataGenerationMethod, Iterable[DataGenerationMethod]]
 
 DEFAULT_DATA_GENERATION_METHODS = (DataGenerationMethod.default(),)
 
@@ -58,11 +29,24 @@ def generate_random_case_id(length: int = 6) -> str:
     return output
 
 
+@dataclass
+class HeaderConfig:
+    """Configuration for generating headers."""
+
+    strategy: SearchStrategy[str] | None = None
+
+
 @dataclass
 class GenerationConfig:
     """Holds various configuration options relevant for data generation."""
 
     # Allow generating `\x00` bytes in strings
     allow_x00: bool = True
+    # Allowing using `null` for optional arguments in GraphQL queries
+    graphql_allow_null: bool = True
     # Generate strings using the given codec
     codec: str | None = "utf-8"
+    # Whether to generate security parameters
+    with_security_parameters: bool = True
+    # Header generation configuration
+    headers: HeaderConfig = field(default_factory=HeaderConfig)

schemathesis/generation/_hypothesis.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+import os
+from functools import lru_cache, reduce
+from operator import or_
+from typing import TYPE_CHECKING, TypeVar
+
+if TYPE_CHECKING:
+    from hypothesis import settings
+    from hypothesis import strategies as st
+
+SCHEMATHESIS_BENCHMARK_SEED = os.environ.get("SCHEMATHESIS_BENCHMARK_SEED")
+
+
+@lru_cache
+def default_settings() -> settings:
+    from hypothesis import HealthCheck, Phase, Verbosity, settings
+
+    return settings(
+        database=None,
+        max_examples=1,
+        deadline=None,
+        verbosity=Verbosity.quiet,
+        phases=(Phase.generate,),
+        suppress_health_check=list(HealthCheck),
+    )
+
+
+T = TypeVar("T")
+
+
+def get_single_example(strategy: st.SearchStrategy[T]) -> T:  # type: ignore[type-var]
+    examples: list[T] = []
+    add_single_example(strategy, examples)
+    return examples[0]
+
+
+def add_single_example(strategy: st.SearchStrategy[T], examples: list[T]) -> None:
+    from hypothesis import given, seed
+
+    @given(strategy)  # type: ignore
+    @default_settings()  # type: ignore
+    def example_generating_inner_function(ex: T) -> None:
+        examples.append(ex)
+
+    example_generating_inner_function._hypothesis_internal_database_key = b""  # type: ignore
+
+    if SCHEMATHESIS_BENCHMARK_SEED is not None:
+        example_generating_inner_function = seed(SCHEMATHESIS_BENCHMARK_SEED)(example_generating_inner_function)
+
+    example_generating_inner_function()
+
+
+def combine_strategies(strategies: list[st.SearchStrategy] | tuple[st.SearchStrategy]) -> st.SearchStrategy:
+    """Combine a list of strategies into a single one.
+
+    If the input is `[a, b, c]`, then the result is equivalent to `a | b | c`.
+    """
+    return reduce(or_, strategies[1:], strategies[0])

schemathesis/generation/_methods.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from enum import Enum
+from typing import Iterable, Union
+
+
+class DataGenerationMethod(str, Enum):
+    """Defines what data Schemathesis generates for tests."""
+
+    # Generate data, that fits the API schema
+    positive = "positive"
+    # Doesn't fit the API schema
+    negative = "negative"
+
+    @classmethod
+    def default(cls) -> DataGenerationMethod:
+        return cls.positive
+
+    @classmethod
+    def all(cls) -> list[DataGenerationMethod]:
+        return list(DataGenerationMethod)
+
+    def as_short_name(self) -> str:
+        return {
+            DataGenerationMethod.positive: "P",
+            DataGenerationMethod.negative: "N",
+        }[self]
+
+    @property
+    def is_positive(self) -> bool:
+        return self == DataGenerationMethod.positive
+
+    @property
+    def is_negative(self) -> bool:
+        return self == DataGenerationMethod.negative
+
+    @classmethod
+    def ensure_list(cls, value: DataGenerationMethodInput) -> list[DataGenerationMethod]:
+        if isinstance(value, DataGenerationMethod):
+            return [value]
+        return list(value)
+
+
+DataGenerationMethodInput = Union[DataGenerationMethod, Iterable[DataGenerationMethod]]