schemathesis 3.25.5__py3-none-any.whl → 4.0.0a1__py3-none-any.whl

schemathesis/experimental/__init__.py

@@ -1,18 +1,21 @@
 import os
 from dataclasses import dataclass, field
 
-from ..constants import TRUE_VALUES
+from schemathesis.core import string_to_boolean
 
 
 @dataclass(eq=False)
 class Experiment:
     name: str
-    verbose_name: str
     env_var: str
     description: str
     discussion_url: str
     _storage: "ExperimentSet" = field(repr=False)
 
+    @property
+    def label(self) -> str:
+        return self.name.lower().replace(" ", "-")
+
     def enable(self) -> None:
         self._storage.enable(self)
 
@@ -25,7 +28,7 @@ class Experiment:
 
     @property
     def is_env_var_set(self) -> bool:
-        return os.getenv(self.env_var, "").lower() in TRUE_VALUES
+        return string_to_boolean(os.getenv(self.env_var, "")) is True
 
 
 @dataclass
@@ -33,12 +36,9 @@ class ExperimentSet:
     available: set = field(default_factory=set)
     enabled: set = field(default_factory=set)
 
-    def create_experiment(
-        self, name: str, verbose_name: str, env_var: str, description: str, discussion_url: str
-    ) -> Experiment:
+    def create_experiment(self, name: str, env_var: str, description: str, discussion_url: str) -> Experiment:
         instance = Experiment(
             name=name,
-            verbose_name=verbose_name,
             env_var=f"{ENV_PREFIX}_{env_var}",
             description=description,
             discussion_url=discussion_url,
@@ -64,11 +64,15 @@ class ExperimentSet:
 
 ENV_PREFIX = "SCHEMATHESIS_EXPERIMENTAL"
 GLOBAL_EXPERIMENTS = ExperimentSet()
-
-OPEN_API_3_1 = GLOBAL_EXPERIMENTS.create_experiment(
-    name="openapi-3.1",
-    verbose_name="OpenAPI 3.1",
-    env_var="OPENAPI_3_1",
-    description="Support for response validation",
-    discussion_url="https://github.com/schemathesis/schemathesis/discussions/1822",
+COVERAGE_PHASE = GLOBAL_EXPERIMENTS.create_experiment(
+    name="Coverage phase",
+    env_var="COVERAGE_PHASE",
+    description="Generate covering test cases",
+    discussion_url="https://github.com/schemathesis/schemathesis/discussions/2418",
+)
+POSITIVE_DATA_ACCEPTANCE = GLOBAL_EXPERIMENTS.create_experiment(
+    name="Positive Data Acceptance",
+    env_var="POSITIVE_DATA_ACCEPTANCE",
+    description="Verifying schema-conformant data is accepted",
+    discussion_url="https://github.com/schemathesis/schemathesis/discussions/2499",
 )

schemathesis/filters.py

@@ -1,15 +1,19 @@
 """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 schemathesis.core.errors import IncorrectUsage
+from schemathesis.core.transforms import resolve_pointer
 
 if TYPE_CHECKING:
-    from .models import APIOperation
+    from schemathesis.schemas import APIOperation
 
 
 class HasAPIOperation(Protocol):
@@ -49,16 +53,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 +78,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 +110,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 +120,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 +138,17 @@ 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 apply_to(self, operations: list[APIOperation]) -> list[APIOperation]:
         """Get a filtered list of the given operations that match the filters."""
@@ -166,6 +188,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 +203,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 +219,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 +234,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,29 +251,32 @@ 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:
             matchers.append(Matcher.for_function(func))
         for attribute, expected, regex in (
-            ("verbose_name", name, name_regex),
+            ("label", name, name_regex),
             ("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
-                raise UsageError(ERROR_EXPECTED_AND_REGEX)
+                raise IncorrectUsage(ERROR_EXPECTED_AND_REGEX)
             if expected is not None:
                 matchers.append(Matcher.for_value(attribute, expected))
             if regex is not None:
                 matchers.append(Matcher.for_regex(attribute, regex))
 
         if not matchers:
-            raise UsageError(ERROR_EMPTY_FILTER)
+            raise IncorrectUsage(ERROR_EMPTY_FILTER)
         filter_ = Filter(matchers=tuple(matchers))
         if filter_ in self._includes or filter_ in self._excludes:
-            raise UsageError(ERROR_FILTER_EXISTS)
+            raise IncorrectUsage(ERROR_FILTER_EXISTS)
         if include:
             self._includes.add(filter_)
         else:
@@ -274,8 +307,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 +321,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 +334,51 @@ 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 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]:
+    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/generation/__init__.py

@@ -1,46 +1,16 @@
 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 schemathesis.generation.modes import GenerationMode as GenerationMode
 
+if TYPE_CHECKING:
+    from hypothesis.strategies import SearchStrategy
 
-DataGenerationMethodInput = Union[DataGenerationMethod, Iterable[DataGenerationMethod]]
 
-DEFAULT_DATA_GENERATION_METHODS = (DataGenerationMethod.default(),)
+DEFAULT_GENERATOR_MODES = (GenerationMode.default(),)
 
 
 CASE_ID_ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
@@ -58,11 +28,25 @@ 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."""
 
+    modes: list[GenerationMode] = field(default_factory=lambda: [GenerationMode.default()])
     # 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/case.py

@@ -0,0 +1,190 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any, Mapping
+
+from schemathesis.checks import CHECKS, CheckContext, CheckFunction, run_checks
+from schemathesis.core import NOT_SET, SCHEMATHESIS_TEST_CASE_HEADER, NotSet, curl
+from schemathesis.core.failures import FailureGroup, failure_report_title, format_failures
+from schemathesis.core.transport import Response
+from schemathesis.generation import generate_random_case_id
+from schemathesis.generation.meta import CaseMetadata
+from schemathesis.generation.overrides import Override, store_components
+from schemathesis.hooks import HookContext, dispatch
+from schemathesis.transport.prepare import prepare_request
+
+if TYPE_CHECKING:
+    import requests.auth
+    from requests.structures import CaseInsensitiveDict
+
+    from schemathesis.schemas import APIOperation
+
+
+@dataclass
+class Case:
+    """A single test case parameters."""
+
+    operation: APIOperation
+    method: str
+    path: str
+    # Unique test case identifier
+    id: str = field(default_factory=generate_random_case_id, compare=False)
+    path_parameters: dict[str, Any] | None = None
+    headers: CaseInsensitiveDict | None = None
+    cookies: dict[str, Any] | None = None
+    query: dict[str, Any] | None = None
+    # By default, there is no body, but we can't use `None` as the default value because it clashes with `null`
+    # which is a valid payload.
+    body: list | dict[str, Any] | str | int | float | bool | bytes | NotSet = NOT_SET
+    # The media type for cases with a payload. For example, "application/json"
+    media_type: str | None = None
+
+    meta: CaseMetadata | None = field(compare=False, default=None)
+
+    _auth: requests.auth.AuthBase | None = None
+    _has_explicit_auth: bool = False
+
+    def __post_init__(self) -> None:
+        self._components = store_components(self)
+
+    @property
+    def _override(self) -> Override:
+        return Override.from_components(self._components, self)
+
+    def __repr__(self) -> str:
+        output = f"{self.__class__.__name__}("
+        first = True
+        for name in ("path_parameters", "headers", "cookies", "query", "body"):
+            value = getattr(self, name)
+            if value is not None and not isinstance(value, NotSet):
+                if first:
+                    first = False
+                else:
+                    output += ", "
+                output += f"{name}={value!r}"
+        return f"{output})"
+
+    def __hash__(self) -> int:
+        return hash(self.as_curl_command({SCHEMATHESIS_TEST_CASE_HEADER: "0"}))
+
+    def _repr_pretty_(self, *args: Any, **kwargs: Any) -> None: ...
+
+    def as_curl_command(self, headers: Mapping[str, Any] | None = None, verify: bool = True) -> str:
+        """Construct a curl command for a given case."""
+        request_data = prepare_request(self, headers, self.operation.schema.output_config.sanitize)
+        return curl.generate(
+            method=str(request_data.method),
+            url=str(request_data.url),
+            body=request_data.body,
+            verify=verify,
+            headers=dict(request_data.headers),
+            known_generated_headers=dict(self.headers or {}),
+        )
+
+    def as_transport_kwargs(self, base_url: str | None = None, headers: dict[str, str] | None = None) -> dict[str, Any]:
+        """Convert the test case into a dictionary acceptable by the underlying transport call."""
+        return self.operation.schema.transport.serialize_case(self, base_url=base_url, headers=headers)
+
+    def call(
+        self,
+        base_url: str | None = None,
+        session: requests.Session | None = None,
+        headers: dict[str, Any] | None = None,
+        params: dict[str, Any] | None = None,
+        cookies: dict[str, Any] | None = None,
+        **kwargs: Any,
+    ) -> Response:
+        hook_context = HookContext(operation=self.operation)
+        dispatch("before_call", hook_context, self, **kwargs)
+        if self.operation.app is not None:
+            kwargs["app"] = self.operation.app
+        response = self.operation.schema.transport.send(
+            self,
+            session=session,
+            base_url=base_url,
+            headers=headers,
+            params=params,
+            cookies=cookies,
+            **kwargs,
+        )
+        dispatch("after_call", hook_context, self, response)
+        return response
+
+    def validate_response(
+        self,
+        response: Response,
+        checks: list[CheckFunction] | None = None,
+        additional_checks: list[CheckFunction] | None = None,
+        excluded_checks: list[CheckFunction] | None = None,
+        headers: dict[str, Any] | None = None,
+        transport_kwargs: dict[str, Any] | None = None,
+    ) -> None:
+        """Validate application response.
+
+        By default, all available checks will be applied.
+
+        :param response: Application response.
+        :param checks: A tuple of check functions that accept ``response`` and ``case``.
+        :param additional_checks: A tuple of additional checks that will be executed after ones from the ``checks``
+            argument.
+        :param excluded_checks: Checks excluded from the default ones.
+        """
+        __tracebackhide__ = True
+        from requests.structures import CaseInsensitiveDict
+
+        checks = [
+            check
+            for check in list(checks or CHECKS.get_all()) + list(additional_checks or [])
+            if check not in set(excluded_checks or [])
+        ]
+
+        ctx = CheckContext(
+            override=self._override,
+            auth=None,
+            headers=CaseInsensitiveDict(headers) if headers else None,
+            config={},
+            transport_kwargs=transport_kwargs,
+            recorder=None,
+        )
+        failures = run_checks(
+            case=self,
+            response=response,
+            ctx=ctx,
+            checks=checks,
+            on_failure=lambda _, collected, failure: collected.add(failure),
+        )
+        if failures:
+            _failures = list(failures)
+            message = failure_report_title(_failures) + "\n"
+            verify = getattr(response, "verify", True)
+            curl = self.as_curl_command(headers=dict(response.request.headers), verify=verify)
+            message += format_failures(
+                case_id=None,
+                response=response,
+                failures=_failures,
+                curl=curl,
+                config=self.operation.schema.output_config,
+            )
+            raise FailureGroup(_failures, message) from None
+
+    def call_and_validate(
+        self,
+        base_url: str | None = None,
+        session: requests.Session | None = None,
+        headers: dict[str, Any] | None = None,
+        checks: list[CheckFunction] | None = None,
+        additional_checks: list[CheckFunction] | None = None,
+        excluded_checks: list[CheckFunction] | None = None,
+        **kwargs: Any,
+    ) -> Response:
+        __tracebackhide__ = True
+        response = self.call(base_url, session, headers, **kwargs)
+        self.validate_response(
+            response,
+            checks,
+            headers=headers,
+            additional_checks=additional_checks,
+            excluded_checks=excluded_checks,
+            transport_kwargs=kwargs,
+        )
+        return response