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

schemathesis/__init__.py

@@ -1,13 +1,13 @@
 from __future__ import annotations
+
 from typing import Any
 
-from . import auths, checks, experimental, contrib, fixups, graphql, hooks, runner, serializers, targets  # noqa: E402
+from . import auths, checks, contrib, experimental, fixups, graphql, hooks, runner, serializers, targets
 from ._lazy_import import lazy_import
-from .generation import DataGenerationMethod, GenerationConfig  # noqa: E402
-from .constants import SCHEMATHESIS_VERSION  # noqa: E402
-from .models import Case  # noqa: E402
-from .specs import openapi  # noqa: E402
-
+from .constants import SCHEMATHESIS_VERSION
+from .generation import DataGenerationMethod, GenerationConfig, HeaderConfig
+from .models import Case
+from .specs import openapi
 
 __version__ = SCHEMATHESIS_VERSION
 

schemathesis/_compat.py

@@ -1,6 +1,6 @@
-from typing import Any, Type, Callable
-from ._lazy_import import lazy_import
+from typing import Any, Callable, Type
 
+from ._lazy_import import lazy_import
 
 __all__ = [  # noqa: F822
     "JSONMixin",

schemathesis/_dependency_versions.py

@@ -1,17 +1,19 @@
 """Compatibility flags based on installed dependency versions."""
-from packaging import version
 
 from importlib import metadata
 
+from packaging import version
 
 WERKZEUG_VERSION = version.parse(metadata.version("werkzeug"))
 IS_WERKZEUG_ABOVE_3 = WERKZEUG_VERSION >= version.parse("3.0")
 IS_WERKZEUG_BELOW_2_1 = WERKZEUG_VERSION < version.parse("2.1.0")
 
 PYTEST_VERSION = version.parse(metadata.version("pytest"))
-IS_PYTEST_ABOVE_54 = PYTEST_VERSION >= version.parse("5.4.0")
 IS_PYTEST_ABOVE_7 = PYTEST_VERSION >= version.parse("7.0.0")
 IS_PYTEST_ABOVE_8 = PYTEST_VERSION >= version.parse("8.0.0")
 
 HYPOTHESIS_VERSION = version.parse(metadata.version("hypothesis"))
 HYPOTHESIS_HAS_STATEFUL_NAMING_IMPROVEMENTS = HYPOTHESIS_VERSION >= version.parse("6.98.14")
+
+PYRATE_LIMITER_VERSION = version.parse(metadata.version("pyrate-limiter"))
+IS_PYRATE_LIMITER_ABOVE_3 = PYRATE_LIMITER_VERSION >= version.parse("3.0")

schemathesis/_hypothesis.py

@@ -1,26 +1,42 @@
 """High-level API for creating Hypothesis tests."""
+
 from __future__ import annotations
 
 import asyncio
+import json
 import warnings
-from typing import Any, Callable, Generator, Mapping, Optional, Tuple
+from functools import wraps
+from itertools import combinations
+from typing import TYPE_CHECKING, Any, Callable, Generator, Mapping
 
 import hypothesis
 from hypothesis import Phase
-from hypothesis import strategies as st
 from hypothesis.errors import HypothesisWarning, Unsatisfiable
-from hypothesis.internal.reflection import proxies
+from hypothesis.internal.entropy import deterministic_PRNG
 from jsonschema.exceptions import SchemaError
 
+from . import _patches
 from .auths import get_auth_storage_from_test
-from .constants import DEFAULT_DEADLINE
+from .constants import DEFAULT_DEADLINE, NOT_SET
 from .exceptions import OperationSchemaError, SerializationNotPossible
-from .generation import DataGenerationMethod, GenerationConfig
+from .experimental import COVERAGE_PHASE
+from .generation import DataGenerationMethod, GenerationConfig, combine_strategies, coverage, get_single_example
 from .hooks import GLOBAL_HOOK_DISPATCHER, HookContext, HookDispatcher
-from .models import APIOperation, Case
+from .models import APIOperation, Case, GenerationMetadata, TestPhase
+from .parameters import ParameterSet
 from .transports.content_types import parse_content_type
 from .transports.headers import has_invalid_characters, is_latin_1_encodable
-from .utils import GivenInput, combine_strategies
+from .types import NotSet
+
+if TYPE_CHECKING:
+    from .utils import GivenInput
+
+# Forcefully initializes Hypothesis' global PRNG to avoid races that initialize it
+# if e.g. Schemathesis CLI is used with multiple workers
+with deterministic_PRNG():
+    pass
+
+_patches.install()
 
 
 def create_test(
@@ -41,17 +57,17 @@ def create_test(
     auth_storage = get_auth_storage_from_test(test)
     strategies = []
     skip_on_not_negated = len(data_generation_methods) == 1 and DataGenerationMethod.negative in data_generation_methods
+    as_strategy_kwargs = as_strategy_kwargs or {}
+    as_strategy_kwargs.update(
+        {
+            "hooks": hook_dispatcher,
+            "auth_storage": auth_storage,
+            "generation_config": generation_config,
+            "skip_on_not_negated": skip_on_not_negated,
+        }
+    )
     for data_generation_method in data_generation_methods:
-        strategies.append(
-            operation.as_strategy(
-                hooks=hook_dispatcher,
-                auth_storage=auth_storage,
-                data_generation_method=data_generation_method,
-                generation_config=generation_config,
-                skip_on_not_negated=skip_on_not_negated,
-                **(as_strategy_kwargs or {}),
-            )
-        )
+        strategies.append(operation.as_strategy(data_generation_method=data_generation_method, **as_strategy_kwargs))
     strategy = combine_strategies(strategies)
     _given_kwargs = (_given_kwargs or {}).copy()
     _given_kwargs.setdefault("case", strategy)
@@ -60,7 +76,7 @@ def create_test(
     # tests in multiple threads because Hypothesis stores some internal attributes on function objects and re-writing
     # them from different threads may lead to unpredictable side-effects.
 
-    @proxies(test)  # type: ignore
+    @wraps(test)
     def test_function(*args: Any, **kwargs: Any) -> Any:
         __tracebackhide__ = True
         return test(*args, **kwargs)
@@ -76,13 +92,26 @@ def create_test(
             wrapped_test.hypothesis.inner_test = make_async_test(test)  # type: ignore
     setup_default_deadline(wrapped_test)
     if settings is not None:
-        wrapped_test = settings(wrapped_test)
+        existing_settings = _get_hypothesis_settings(wrapped_test)
+        if existing_settings is not None:
+            # Merge the user-provided settings with the current ones
+            default = hypothesis.settings.default
+            wrapped_test._hypothesis_internal_use_settings = hypothesis.settings(
+                wrapped_test._hypothesis_internal_use_settings,
+                **{item: value for item, value in settings.__dict__.items() if value != getattr(default, item)},
+            )
+        else:
+            wrapped_test = settings(wrapped_test)
     existing_settings = _get_hypothesis_settings(wrapped_test)
     if existing_settings is not None:
         existing_settings = remove_explain_phase(existing_settings)
         wrapped_test._hypothesis_internal_use_settings = existing_settings  # type: ignore
         if Phase.explicit in existing_settings.phases:
-            wrapped_test = add_examples(wrapped_test, operation, hook_dispatcher=hook_dispatcher)
+            wrapped_test = add_examples(
+                wrapped_test, operation, hook_dispatcher=hook_dispatcher, as_strategy_kwargs=as_strategy_kwargs
+            )
+            if COVERAGE_PHASE.is_enabled:
+                wrapped_test = add_coverage(wrapped_test, operation, data_generation_methods)
     return wrapped_test
 
 
@@ -122,12 +151,20 @@ def make_async_test(test: Callable) -> Callable:
     return async_run
 
 
-def add_examples(test: Callable, operation: APIOperation, hook_dispatcher: HookDispatcher | None = None) -> Callable:
+def add_examples(
+    test: Callable,
+    operation: APIOperation,
+    hook_dispatcher: HookDispatcher | None = None,
+    as_strategy_kwargs: dict[str, Any] | None = None,
+) -> Callable:
     """Add examples to the Hypothesis test, if they are specified in the schema."""
     from hypothesis_jsonschema._canonicalise import HypothesisRefResolutionError
 
     try:
-        examples: list[Case] = [get_single_example(strategy) for strategy in operation.get_strategies_from_examples()]
+        examples: list[Case] = [
+            get_single_example(strategy)
+            for strategy in operation.get_strategies_from_examples(as_strategy_kwargs=as_strategy_kwargs)
+        ]
     except (
         OperationSchemaError,
         HypothesisRefResolutionError,
@@ -162,18 +199,316 @@ def add_examples(test: Callable, operation: APIOperation, hook_dispatcher: HookD
             if invalid_headers:
                 add_invalid_example_header_mark(original_test, invalid_headers)
                 continue
-        if example.media_type is not None:
-            try:
-                media_type = parse_content_type(example.media_type)
-                if media_type == ("application", "x-www-form-urlencoded"):
-                    example.body = prepare_urlencoded(example.body)
-            except ValueError:
-                pass
+        adjust_urlencoded_payload(example)
         test = hypothesis.example(case=example)(test)
     return test
 
 
-def find_invalid_headers(headers: Mapping) -> Generator[Tuple[str, str], None, None]:
+def adjust_urlencoded_payload(case: Case) -> None:
+    if case.media_type is not None:
+        try:
+            media_type = parse_content_type(case.media_type)
+            if media_type == ("application", "x-www-form-urlencoded"):
+                case.body = prepare_urlencoded(case.body)
+        except ValueError:
+            pass
+
+
+def add_coverage(
+    test: Callable, operation: APIOperation, data_generation_methods: list[DataGenerationMethod]
+) -> Callable:
+    for example in _iter_coverage_cases(operation, data_generation_methods):
+        adjust_urlencoded_payload(example)
+        test = hypothesis.example(case=example)(test)
+    return test
+
+
+def _iter_coverage_cases(
+    operation: APIOperation, data_generation_methods: list[DataGenerationMethod]
+) -> Generator[Case, None, None]:
+    from .specs.openapi.constants import LOCATION_TO_CONTAINER
+    from .specs.openapi.examples import find_in_responses, find_matching_in_responses
+
+    def _stringify_value(val: Any, location: str) -> str | list[str]:
+        if isinstance(val, list):
+            if location == "query":
+                # Having a list here ensures there will be multiple query parameters wit the same name
+                return [json.dumps(item) for item in val]
+            # use comma-separated values style for arrays
+            return ",".join(json.dumps(sub) for sub in val)
+        return json.dumps(val)
+
+    generators: dict[tuple[str, str], Generator[coverage.GeneratedValue, None, None]] = {}
+    template: dict[str, Any] = {}
+    responses = find_in_responses(operation)
+    for parameter in operation.iter_parameters():
+        location = parameter.location
+        name = parameter.name
+        schema = parameter.as_json_schema(operation, update_quantifiers=False)
+        for value in find_matching_in_responses(responses, parameter.name):
+            schema.setdefault("examples", []).append(value)
+        gen = coverage.cover_schema_iter(
+            coverage.CoverageContext(location=location, data_generation_methods=data_generation_methods), schema
+        )
+        value = next(gen, NOT_SET)
+        if isinstance(value, NotSet):
+            continue
+        container = template.setdefault(LOCATION_TO_CONTAINER[location], {})
+        if location in ("header", "cookie", "path", "query") and not isinstance(value.value, str):
+            container[name] = _stringify_value(value.value, location)
+        else:
+            container[name] = value.value
+        generators[(location, name)] = gen
+    if operation.body:
+        for body in operation.body:
+            schema = body.as_json_schema(operation, update_quantifiers=False)
+            # Definition could be a list for Open API 2.0
+            definition = body.definition if isinstance(body.definition, dict) else {}
+            examples = [example["value"] for example in definition.get("examples", {}).values() if "value" in example]
+            if examples:
+                schema.setdefault("examples", []).extend(examples)
+            gen = coverage.cover_schema_iter(
+                coverage.CoverageContext(location="body", data_generation_methods=data_generation_methods), schema
+            )
+            value = next(gen, NOT_SET)
+            if isinstance(value, NotSet):
+                continue
+            if "body" not in template:
+                template["body"] = value.value
+                template["media_type"] = body.media_type
+            case = operation.make_case(**{**template, "body": value.value, "media_type": body.media_type})
+            case.data_generation_method = value.data_generation_method
+            case.meta = _make_meta(
+                description=value.description,
+                location=value.location,
+                parameter=body.media_type,
+                parameter_location="body",
+            )
+            yield case
+            for next_value in gen:
+                case = operation.make_case(**{**template, "body": next_value.value, "media_type": body.media_type})
+                case.data_generation_method = next_value.data_generation_method
+                case.meta = _make_meta(
+                    description=next_value.description,
+                    location=next_value.location,
+                    parameter=body.media_type,
+                    parameter_location="body",
+                )
+                yield case
+    elif DataGenerationMethod.positive in data_generation_methods:
+        case = operation.make_case(**template)
+        case.data_generation_method = DataGenerationMethod.positive
+        case.meta = _make_meta(description="Default positive test case")
+        yield case
+
+    for (location, name), gen in generators.items():
+        container_name = LOCATION_TO_CONTAINER[location]
+        container = template[container_name]
+        for value in gen:
+            if location in ("header", "cookie", "path", "query") and not isinstance(value.value, str):
+                generated = _stringify_value(value.value, location)
+            else:
+                generated = value.value
+            case = operation.make_case(**{**template, container_name: {**container, name: generated}})
+            case.data_generation_method = value.data_generation_method
+            case.meta = _make_meta(
+                description=value.description,
+                location=value.location,
+                parameter=name,
+                parameter_location=location,
+            )
+            yield case
+    if DataGenerationMethod.negative in data_generation_methods:
+        # Generate HTTP methods that are not specified in the spec
+        # NOTE: The HEAD method is excluded
+        methods = {"get", "put", "post", "delete", "options", "patch", "trace"} - set(operation.schema[operation.path])
+        for method in sorted(methods):
+            case = operation.make_case(**template)
+            case._explicit_method = method
+            case.data_generation_method = DataGenerationMethod.negative
+            case.meta = _make_meta(description=f"Unspecified HTTP method: {method.upper()}")
+            yield case
+        # Generate duplicate query parameters
+        if operation.query:
+            container = template["query"]
+            for parameter in operation.query:
+                value = container[parameter.name]
+                case = operation.make_case(**{**template, "query": {**container, parameter.name: [value, value]}})
+                case.data_generation_method = DataGenerationMethod.negative
+                case.meta = _make_meta(
+                    description=f"Duplicate `{parameter.name}` query parameter",
+                    location=None,
+                    parameter=parameter.name,
+                    parameter_location="query",
+                )
+                yield case
+        # Generate missing required parameters
+        for parameter in operation.iter_parameters():
+            if parameter.is_required and parameter.location != "path":
+                name = parameter.name
+                location = parameter.location
+                container_name = LOCATION_TO_CONTAINER[location]
+                container = template[container_name]
+                case = operation.make_case(
+                    **{**template, container_name: {k: v for k, v in container.items() if k != name}}
+                )
+                case.data_generation_method = DataGenerationMethod.negative
+                case.meta = _make_meta(
+                    description=f"Missing `{name}` at {location}",
+                    location=None,
+                    parameter=name,
+                    parameter_location=location,
+                )
+                yield case
+    # Generate combinations for each location
+    for location, parameter_set in [
+        ("query", operation.query),
+        ("header", operation.headers),
+        ("cookie", operation.cookies),
+    ]:
+        if not parameter_set:
+            continue
+
+        container_name = LOCATION_TO_CONTAINER[location]
+        base_container = template.get(container_name, {})
+
+        # Get required and optional parameters
+        required = {p.name for p in parameter_set if p.is_required}
+        all_params = {p.name for p in parameter_set}
+        optional = sorted(all_params - required)
+
+        # Helper function to create and yield a case
+        def make_case(
+            container_values: dict,
+            description: str,
+            _location: str,
+            _container_name: str,
+            _parameter: str | None,
+            _data_generation_method: DataGenerationMethod,
+        ) -> Case:
+            if _location in ("header", "cookie", "path", "query"):
+                container = {
+                    name: _stringify_value(val, _location) if not isinstance(val, str) else val
+                    for name, val in container_values.items()
+                }
+            else:
+                container = container_values
+
+            case = operation.make_case(**{**template, _container_name: container})
+            case.data_generation_method = _data_generation_method
+            case.meta = _make_meta(
+                description=description,
+                location=None,
+                parameter=_parameter,
+                parameter_location=_location,
+            )
+            return case
+
+        def _combination_schema(
+            combination: dict[str, Any], _required: set[str], _parameter_set: ParameterSet
+        ) -> dict[str, Any]:
+            return {
+                "properties": {
+                    parameter.name: parameter.as_json_schema(operation)
+                    for parameter in _parameter_set
+                    if parameter.name in combination
+                },
+                "required": list(_required),
+                "additionalProperties": False,
+            }
+
+        def _yield_negative(
+            subschema: dict[str, Any], _location: str, _container_name: str
+        ) -> Generator[Case, None, None]:
+            for more in coverage.cover_schema_iter(
+                coverage.CoverageContext(location=_location, data_generation_methods=[DataGenerationMethod.negative]),
+                subschema,
+            ):
+                yield make_case(
+                    more.value,
+                    more.description,
+                    _location,
+                    _container_name,
+                    more.parameter,
+                    DataGenerationMethod.negative,
+                )
+
+        # 1. Generate only required properties
+        if required and all_params != required:
+            only_required = {k: v for k, v in base_container.items() if k in required}
+            if DataGenerationMethod.positive in data_generation_methods:
+                yield make_case(
+                    only_required,
+                    "Only required properties",
+                    location,
+                    container_name,
+                    None,
+                    DataGenerationMethod.positive,
+                )
+            if DataGenerationMethod.negative in data_generation_methods:
+                subschema = _combination_schema(only_required, required, parameter_set)
+                for case in _yield_negative(subschema, location, container_name):
+                    # Already generated in one of the blocks above
+                    if location != "path" and not case.meta.description.startswith("Missing required property"):
+                        yield case
+
+        # 2. Generate combinations with required properties and one optional property
+        for opt_param in optional:
+            combo = {k: v for k, v in base_container.items() if k in required or k == opt_param}
+            if combo != base_container and DataGenerationMethod.positive in data_generation_methods:
+                yield make_case(
+                    combo,
+                    f"All required properties and optional '{opt_param}'",
+                    location,
+                    container_name,
+                    None,
+                    DataGenerationMethod.positive,
+                )
+                if DataGenerationMethod.negative in data_generation_methods:
+                    subschema = _combination_schema(combo, required, parameter_set)
+                    for case in _yield_negative(subschema, location, container_name):
+                        # Already generated in one of the blocks above
+                        if location != "path" and not case.meta.description.startswith("Missing required property"):
+                            yield case
+
+        # 3. Generate one combination for each size from 2 to N-1 of optional parameters
+        if len(optional) > 1 and DataGenerationMethod.positive in data_generation_methods:
+            for size in range(2, len(optional)):
+                for combination in combinations(optional, size):
+                    combo = {k: v for k, v in base_container.items() if k in required or k in combination}
+                    if combo != base_container:
+                        yield make_case(
+                            combo,
+                            f"All required and {size} optional properties",
+                            location,
+                            container_name,
+                            None,
+                            DataGenerationMethod.positive,
+                        )
+
+
+def _make_meta(
+    *,
+    description: str,
+    location: str | None = None,
+    parameter: str | None = None,
+    parameter_location: str | None = None,
+) -> GenerationMetadata:
+    return GenerationMetadata(
+        query=None,
+        path_parameters=None,
+        headers=None,
+        cookies=None,
+        body=None,
+        phase=TestPhase.COVERAGE,
+        description=description,
+        location=location,
+        parameter=parameter,
+        parameter_location=parameter_location,
+    )
+
+
+def find_invalid_headers(headers: Mapping) -> Generator[tuple[str, str], None, None]:
     for name, value in headers.items():
         if not is_latin_1_encodable(value) or has_invalid_characters(name, value):
             yield name, value
@@ -187,7 +522,7 @@ def prepare_urlencoded(data: Any) -> Any:
                 for key, value in item.items():
                     output.append((key, value))
             else:
-                output.append(item)
+                output.append((item, "arbitrary-value"))
         return output
     return data
 
@@ -204,11 +539,11 @@ def add_non_serializable_mark(test: Callable, exc: SerializationNotPossible) ->
     test._schemathesis_non_serializable = exc  # type: ignore
 
 
-def get_non_serializable_mark(test: Callable) -> Optional[SerializationNotPossible]:
+def get_non_serializable_mark(test: Callable) -> SerializationNotPossible | None:
     return getattr(test, "_schemathesis_non_serializable", None)
 
 
-def get_invalid_regex_mark(test: Callable) -> Optional[SchemaError]:
+def get_invalid_regex_mark(test: Callable) -> SchemaError | None:
     return getattr(test, "_schemathesis_invalid_regex", None)
 
 
@@ -216,31 +551,9 @@ def add_invalid_regex_mark(test: Callable, exc: SchemaError) -> None:
     test._schemathesis_invalid_regex = exc  # type: ignore
 
 
-def get_invalid_example_headers_mark(test: Callable) -> Optional[dict[str, str]]:
+def get_invalid_example_headers_mark(test: Callable) -> dict[str, str] | None:
     return getattr(test, "_schemathesis_invalid_example_headers", None)
 
 
 def add_invalid_example_header_mark(test: Callable, headers: dict[str, str]) -> None:
     test._schemathesis_invalid_example_headers = headers  # type: ignore
-
-
-def get_single_example(strategy: st.SearchStrategy[Case]) -> Case:
-    examples: list[Case] = []
-    add_single_example(strategy, examples)
-    return examples[0]
-
-
-def add_single_example(strategy: st.SearchStrategy[Case], examples: list[Case]) -> None:
-    @hypothesis.given(strategy)  # type: ignore
-    @hypothesis.settings(  # type: ignore
-        database=None,
-        max_examples=1,
-        deadline=None,
-        verbosity=hypothesis.Verbosity.quiet,
-        phases=(hypothesis.Phase.generate,),
-        suppress_health_check=list(hypothesis.HealthCheck),
-    )
-    def example_generating_inner_function(ex: Case) -> None:
-        examples.append(ex)
-
-    example_generating_inner_function()

schemathesis/_lazy_import.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 from typing import Any, Callable
 
 

schemathesis/_override.py

@@ -1,13 +1,14 @@
 from __future__ import annotations
+
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 
 from .exceptions import UsageError
-from .parameters import ParameterSet
-from .types import GenericTest
 
 if TYPE_CHECKING:
     from .models import APIOperation
+    from .parameters import ParameterSet
+    from .types import GenericTest
 
 
 @dataclass
@@ -36,7 +37,7 @@ def _for_parameters(overridden: dict[str, str], defined: ParameterSet) -> dict[s
     return output
 
 
-def get_override_from_mark(test: GenericTest) -> Optional[CaseOverride]:
+def get_override_from_mark(test: GenericTest) -> CaseOverride | None:
     return getattr(test, "_schemathesis_override", None)
 
 

schemathesis/_patches.py

@@ -0,0 +1,21 @@
+"""A set of performance-related patches."""
+
+from typing import Any
+
+
+def install() -> None:
+    from hypothesis.internal.reflection import is_first_param_referenced_in_function
+    from hypothesis.strategies._internal import core
+    from hypothesis_jsonschema import _from_schema, _resolve
+
+    from .internal.copy import fast_deepcopy
+
+    # This one is used a lot, and under the hood it re-parses the AST of the same function
+    def _is_first_param_referenced_in_function(f: Any) -> bool:
+        if f.__name__ == "from_object_schema" and f.__module__ == "hypothesis_jsonschema._from_schema":
+            return True
+        return is_first_param_referenced_in_function(f)
+
+    core.is_first_param_referenced_in_function = _is_first_param_referenced_in_function  # type: ignore
+    _resolve.deepcopy = fast_deepcopy  # type: ignore
+    _from_schema.deepcopy = fast_deepcopy  # type: ignore

schemathesis/_rate_limiter.py

@@ -0,0 +1,7 @@
+from ._dependency_versions import IS_PYRATE_LIMITER_ABOVE_3
+
+if IS_PYRATE_LIMITER_ABOVE_3:
+    from pyrate_limiter import Limiter, Rate, RateItem
+else:
+    from pyrate_limiter import Limiter
+    from pyrate_limiter import RequestRate as Rate