schemathesis 3.34.3__py3-none-any.whl → 3.35.0__py3-none-any.whl

schemathesis/_hypothesis.py

@@ -8,21 +8,21 @@ from typing import Any, Callable, Generator, Mapping, Optional, Tuple
 
 import hypothesis
 from hypothesis import Phase
-from hypothesis import strategies as st
 from hypothesis.errors import HypothesisWarning, Unsatisfiable
 from hypothesis.internal.entropy import deterministic_PRNG
 from hypothesis.internal.reflection import proxies
 from jsonschema.exceptions import SchemaError
 
 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 .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 .utils import GivenInput
 
 # Forcefully initializes Hypothesis' global PRNG to avoid races that initilize it
 # if e.g. Schemathesis CLI is used with multiple workers
@@ -101,6 +101,8 @@ def create_test(
             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
 
 
@@ -199,6 +201,55 @@ def add_examples(
     return test
 
 
+def add_coverage(
+    test: Callable, operation: APIOperation, data_generation_methods: list[DataGenerationMethod]
+) -> Callable:
+    for example in _iter_coverage_cases(operation, data_generation_methods):
+        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
+
+    ctx = coverage.CoverageContext(data_generation_methods=data_generation_methods)
+    generators: dict[tuple[str, str], Generator] = {}
+    template: dict[str, Any] = {}
+    for parameter in operation.iter_parameters():
+        schema = parameter.as_json_schema(operation)
+        gen = coverage.cover_schema_iter(ctx, schema)
+        value = next(gen, NOT_SET)
+        if value is NOT_SET:
+            continue
+        location = parameter.location
+        name = parameter.name
+        container = template.setdefault(LOCATION_TO_CONTAINER[location], {})
+        container[name] = value
+        generators[(location, name)] = gen
+    if operation.body:
+        for body in operation.body:
+            schema = body.as_json_schema(operation)
+            gen = coverage.cover_schema_iter(ctx, schema)
+            value = next(gen, NOT_SET)
+            if value is NOT_SET:
+                continue
+            if "body" not in template:
+                template["body"] = value
+                template["media_type"] = body.media_type
+            yield operation.make_case(**{**template, "body": value, "media_type": body.media_type})
+            for next_value in gen:
+                yield operation.make_case(**{**template, "body": next_value, "media_type": body.media_type})
+    else:
+        yield operation.make_case(**template)
+    for (location, name), gen in generators.items():
+        container_name = LOCATION_TO_CONTAINER[location]
+        container = template[container_name]
+        for value in gen:
+            yield operation.make_case(**{**template, container_name: {**container, name: value}})
+
+
 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):
@@ -248,25 +299,3 @@ def get_invalid_example_headers_mark(test: Callable) -> Optional[dict[str, str]]
 
 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/cli/__init__.py

@@ -11,7 +11,7 @@ from collections import defaultdict
 from dataclasses import dataclass
 from enum import Enum
 from queue import Queue
-from typing import TYPE_CHECKING, Any, Callable, Generator, Iterable, Literal, NoReturn, Sequence, cast
+from typing import TYPE_CHECKING, Any, Callable, Generator, Iterable, Literal, NoReturn, Sequence, Type, cast
 from urllib.parse import urlparse
 
 import click
@@ -42,7 +42,7 @@ from ..internal.datetime import current_datetime
 from ..internal.output import OutputConfig
 from ..internal.validation import file_exists
 from ..loaders import load_app, load_yaml
-from ..models import APIOperation, Case, CheckFunction
+from ..models import Case, CheckFunction
 from ..runner import events, prepare_hypothesis_settings, probes
 from ..specs.graphql import loaders as gql_loaders
 from ..specs.openapi import loaders as oas_loaders
@@ -50,11 +50,12 @@ from ..stateful import Stateful
 from ..targets import Target
 from ..transports import RequestConfig
 from ..transports.auth import get_requests_auth
-from ..types import Filter, PathLike, RequestCert
+from ..types import PathLike, RequestCert
 from . import callbacks, cassettes, output
 from .constants import DEFAULT_WORKERS, MAX_WORKERS, MIN_WORKERS, HealthCheck, Phase, Verbosity
 from .context import ExecutionContext, FileReportContext, ServiceReportContext
 from .debug import DebugOutputHandler
+from .handlers import EventHandler
 from .junitxml import JunitXMLHandler
 from .options import CsvChoice, CsvEnumChoice, CustomHelpMessageChoice, NotSet, OptionalInt
 from .sanitization import SanitizationHandler
@@ -66,13 +67,13 @@ if TYPE_CHECKING:
     from ..schemas import BaseSchema
     from ..service.client import ServiceClient
     from ..specs.graphql.schemas import GraphQLSchema
-    from .handlers import EventHandler
 
 
 def _get_callable_names(items: tuple[Callable, ...]) -> tuple[str, ...]:
     return tuple(item.__name__ for item in items)
 
 
+CUSTOM_HANDLERS: list[Type[EventHandler]] = []
 CONTEXT_SETTINGS = {"help_option_names": ["-h", "--help"]}
 
 DEFAULT_CHECKS_NAMES = _get_callable_names(checks_module.DEFAULT_CHECKS)
@@ -759,6 +760,7 @@ The report data, consisting of a tar gz file with multiple JSON files, is subjec
             experimental.SCHEMA_ANALYSIS.name,
             experimental.STATEFUL_TEST_RUNNER.name,
             experimental.STATEFUL_ONLY.name,
+            experimental.COVERAGE_PHASE.name,
         ]
     ),
     callback=callbacks.convert_experimental,
@@ -927,6 +929,7 @@ def run(
     schemathesis_io_telemetry: bool = True,
     hosts_file: PathLike = service.DEFAULT_HOSTS_PATH,
     force_color: bool = False,
+    **__kwargs,
 ) -> None:
     """Run tests against an API using a specified SCHEMA.
 
@@ -1212,6 +1215,7 @@ def run(
     )
     execute(
         event_stream,
+        ctx=ctx,
         hypothesis_settings=hypothesis_settings,
         workers_num=workers_num,
         rate_limit=rate_limit,
@@ -1595,6 +1599,7 @@ class OutputStyle(Enum):
 def execute(
     event_stream: Generator[events.ExecutionEvent, None, None],
     *,
+    ctx: click.Context,
     hypothesis_settings: hypothesis.settings,
     workers_num: int,
     rate_limit: str | None,
@@ -1669,6 +1674,8 @@ def execute(
                 cassette_path, format=cassette_format, preserve_exact_body_bytes=cassette_preserve_exact_body_bytes
             )
         )
+    for custom_handler in CUSTOM_HANDLERS:
+        handlers.append(custom_handler(*ctx.args, **ctx.params))
     handlers.append(get_output_handler(workers_num))
     if sanitize_output:
         handlers.insert(0, SanitizationHandler())
@@ -2000,6 +2007,20 @@ def decide_color_output(ctx: click.Context, no_color: bool, force_color: bool) -
         ctx.color = False
 
 
+def add_option(*args: Any, cls: Type = click.Option, **kwargs: Any) -> None:
+    """Add a new CLI option to `st run`."""
+    run.params.append(cls(args, **kwargs))
+
+
+def handler() -> Callable[[Type], None]:
+    """Register a new CLI event handler."""
+
+    def _wrapper(cls: Type) -> None:
+        CUSTOM_HANDLERS.append(cls)
+
+    return _wrapper
+
+
 @HookDispatcher.register_spec([HookScope.GLOBAL])
 def after_init_cli_run_handlers(
     context: HookContext, handlers: list[EventHandler], execution_context: ExecutionContext

schemathesis/cli/context.py

@@ -60,7 +60,11 @@ class ExecutionContext:
     analysis: Result[AnalysisResult, Exception] | None = None
     output_config: OutputConfig = field(default_factory=OutputConfig)
     state_machine_sink: StateMachineSink | None = None
+    summary_lines: list[str] = field(default_factory=list)
 
     @deprecated_property(removed_in="4.0", replacement="show_trace")
     def show_errors_tracebacks(self) -> bool:
         return self.show_trace
+
+    def add_summary_line(self, line: str) -> None:
+        self.summary_lines.append(line)

schemathesis/cli/handlers.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
     from ..runner import events
@@ -8,6 +8,9 @@ if TYPE_CHECKING:
 
 
 class EventHandler:
+    def __init__(self, *args: Any, **params: Any) -> None:
+        pass
+
     def handle_event(self, context: ExecutionContext, event: events.ExecutionEvent) -> None:
         raise NotImplementedError
 

schemathesis/cli/output/default.py

@@ -850,6 +850,10 @@ def handle_finished(context: ExecutionContext, event: events.Finished) -> None:
     display_application_logs(context, event)
     display_analysis(context)
     display_statistic(context, event)
+    if context.summary_lines:
+        click.echo()
+        for line in context.summary_lines:
+            click.echo(line)
     click.echo()
     display_summary(event)
 

schemathesis/contrib/openapi/fill_missing_examples.py

@@ -18,7 +18,7 @@ def uninstall() -> None:
 
 def before_add_examples(context: HookContext, examples: list[Case]) -> None:
     if not examples and context.operation is not None:
-        from ..._hypothesis import add_single_example
+        from ...generation import add_single_example
 
         strategy = context.operation.as_strategy()
         add_single_example(strategy, examples)

schemathesis/experimental/__init__.py

@@ -93,3 +93,10 @@ STATEFUL_ONLY = GLOBAL_EXPERIMENTS.create_experiment(
     description="Run only stateful tests",
     discussion_url="https://github.com/schemathesis/schemathesis/discussions/2262",
 )
+COVERAGE_PHASE = GLOBAL_EXPERIMENTS.create_experiment(
+    name="coverage-phase",
+    verbose_name="Coverage phase",
+    env_var="COVERAGE_PHASE",
+    description="Generate covering test cases",
+    discussion_url="https://github.com/schemathesis/schemathesis/discussions/2418",
+)

schemathesis/generation/__init__.py

@@ -2,48 +2,15 @@ from __future__ import annotations
 
 import random
 from dataclasses import dataclass, field
-from enum import Enum
-from typing import TYPE_CHECKING, Iterable, Union
+from typing import TYPE_CHECKING
+
+from ._hypothesis import add_single_example, combine_strategies, get_single_example  # noqa: E402
+from ._methods import DataGenerationMethod, DataGenerationMethodInput  # noqa: E402
 
 if TYPE_CHECKING:
     from hypothesis.strategies import SearchStrategy
 
 
-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
-
-    @classmethod
-    def ensure_list(cls, value: DataGenerationMethodInput) -> list[DataGenerationMethod]:
-        if isinstance(value, DataGenerationMethod):
-            return [value]
-        return list(value)
-
-
-DataGenerationMethodInput = Union[DataGenerationMethod, Iterable[DataGenerationMethod]]
-
 DEFAULT_DATA_GENERATION_METHODS = (DataGenerationMethod.default(),)
 
 

schemathesis/generation/_hypothesis.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+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
+
+
+@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
+
+    @given(strategy)  # type: ignore
+    @default_settings()  # type: ignore
+    def example_generating_inner_function(ex: T) -> None:
+        examples.append(ex)
+
+    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,40 @@
+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_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]]

schemathesis/generation/coverage.py

@@ -0,0 +1,433 @@
+from __future__ import annotations
+
+import json
+from contextlib import suppress
+from dataclasses import dataclass, field
+from functools import lru_cache
+from typing import Any, Generator, Set, TypeVar, cast
+
+import jsonschema
+from hypothesis import strategies as st
+from hypothesis.errors import Unsatisfiable
+from hypothesis_jsonschema import from_schema
+from hypothesis_jsonschema._canonicalise import canonicalish
+
+from ._hypothesis import combine_strategies, get_single_example
+from ._methods import DataGenerationMethod
+
+BUFFER_SIZE = 8 * 1024
+FLOAT_STRATEGY: st.SearchStrategy = st.floats(allow_nan=False, allow_infinity=False).map(lambda x: x or 0.0)
+NUMERIC_STRATEGY: st.SearchStrategy = st.integers() | FLOAT_STRATEGY
+JSON_STRATEGY: st.SearchStrategy = st.recursive(
+    st.none() | st.booleans() | NUMERIC_STRATEGY | st.text(),
+    lambda strategy: st.lists(strategy, max_size=3) | st.dictionaries(st.text(), strategy, max_size=3),
+)
+ARRAY_STRATEGY: st.SearchStrategy = st.lists(JSON_STRATEGY)
+OBJECT_STRATEGY: st.SearchStrategy = st.dictionaries(st.text(), JSON_STRATEGY)
+
+UNKNOWN_PROPERTY_KEY = "x-schemathesis-unknown-property"
+UNKNOWN_PROPERTY_VALUE = 42
+
+
+@lru_cache(maxsize=128)
+def cached_draw(strategy: st.SearchStrategy) -> Any:
+    return get_single_example(strategy)
+
+
+@dataclass
+class CoverageContext:
+    data_generation_methods: list[DataGenerationMethod] = field(default_factory=DataGenerationMethod.all)
+
+    @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 generate_from(self, strategy: st.SearchStrategy, cached: bool = False) -> Any:
+        if cached:
+            value = cached_draw(strategy)
+        else:
+            value = get_single_example(strategy)
+        return value
+
+    def generate_from_schema(self, schema: dict) -> Any:
+        return self.generate_from(from_schema(schema))
+
+
+T = TypeVar("T")
+
+
+def _to_hashable_key(value: T) -> T | tuple[type, str]:
+    if isinstance(value, (dict, list)):
+        serialized = json.dumps(value, sort_keys=True)
+        return (type(value), serialized)
+    return value
+
+
+def cover_schema(ctx: CoverageContext, schema: dict) -> list:
+    return list(cover_schema_iter(ctx, schema))
+
+
+def _cover_positive_for_type(ctx: CoverageContext, schema: dict, ty: str | None) -> Generator:
+    if ty == "object" or ty == "array":
+        template_schema = _get_template_schema(schema, ty)
+        template = ctx.generate_from_schema(template_schema)
+    else:
+        template = None
+    if DataGenerationMethod.positive in ctx.data_generation_methods:
+        ctx = ctx.with_positive()
+        enum = schema.get("enum")
+        const = schema.get("const")
+        for key in ("anyOf", "oneOf"):
+            sub_schemas = schema.get(key)
+            if sub_schemas is not None:
+                for sub_schema in sub_schemas:
+                    yield from cover_schema_iter(ctx, sub_schema)
+        all_of = schema.get("allOf")
+        if all_of is not None:
+            if len(all_of) == 1:
+                yield from cover_schema_iter(ctx, all_of[0])
+            else:
+                canonical = canonicalish(schema)
+                yield from cover_schema_iter(ctx, canonical)
+        if enum is not None:
+            yield from enum
+        elif const is not None:
+            yield const
+        elif ty is not None:
+            if ty == "null":
+                yield None
+            if ty == "boolean":
+                yield True
+                yield False
+            if ty == "string":
+                yield from _positive_string(ctx, schema)
+            if ty == "integer" or ty == "number":
+                yield from _positive_number(ctx, schema)
+            if ty == "array":
+                yield from _positive_array(ctx, schema, cast(list, template))
+            if ty == "object":
+                yield from _positive_object(ctx, schema, cast(dict, template))
+
+
+def cover_schema_iter(ctx: CoverageContext, schema: dict) -> Generator:
+    types = schema.get("type", [])
+    if not isinstance(types, list):
+        types = [types]
+    if not types:
+        with suppress(Unsatisfiable, jsonschema.RefResolutionError):
+            yield from _cover_positive_for_type(ctx, schema, None)
+    for ty in types:
+        with suppress(Unsatisfiable, jsonschema.RefResolutionError):
+            yield from _cover_positive_for_type(ctx, schema, ty)
+    if DataGenerationMethod.negative in ctx.data_generation_methods:
+        template = None
+        seen: Set[Any | tuple[type, str]] = set()
+        for key, value in schema.items():
+            with suppress(Unsatisfiable, jsonschema.RefResolutionError):
+                if key == "enum":
+                    yield from _negative_enum(ctx, value)
+                elif key == "const":
+                    yield from _negative_enum(ctx, [value])
+                elif key == "type":
+                    yield from _negative_type(ctx, seen, value)
+                elif key == "properties":
+                    template = template or ctx.generate_from_schema(_get_template_schema(schema, "object"))
+                    yield from _negative_properties(ctx, template, value)
+                elif key == "pattern":
+                    yield from _negative_pattern(ctx, value)
+                elif key == "format" and ("string" in types or not types):
+                    yield from _negative_format(ctx, schema, value)
+                elif key == "maximum":
+                    next = value + 1
+                    yield next
+                    seen.add(next)
+                elif key == "minimum":
+                    next = value - 1
+                    yield next
+                    seen.add(next)
+                elif key == "exclusiveMaximum" or key == "exclusiveMinimum" and value not in seen:
+                    yield value
+                    seen.add(value)
+                elif key == "multipleOf":
+                    yield from _negative_multiple_of(ctx, schema, value)
+                elif key == "minLength" and 0 < value < BUFFER_SIZE and "pattern" not in schema:
+                    yield ctx.generate_from_schema({**schema, "minLength": value - 1, "maxLength": value - 1})
+                elif key == "maxLength" and value < BUFFER_SIZE and "pattern" not in schema:
+                    yield ctx.generate_from_schema({**schema, "minLength": value + 1, "maxLength": value + 1})
+                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:
+                    template = template or ctx.generate_from_schema(_get_template_schema(schema, "object"))
+                    yield {**template, UNKNOWN_PROPERTY_KEY: UNKNOWN_PROPERTY_VALUE}
+                elif key == "allOf":
+                    nctx = ctx.with_negative()
+                    if len(value) == 1:
+                        yield from cover_schema_iter(nctx, value[0])
+                    else:
+                        canonical = canonicalish(schema)
+                        yield from cover_schema_iter(nctx, canonical)
+                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)
+
+
+def _get_template_schema(schema: dict, ty: str) -> dict:
+    if ty == "object":
+        properties = schema.get("properties")
+        if properties is not None:
+            return {
+                **schema,
+                "required": list(properties),
+                "type": ty,
+                "properties": {
+                    k: _get_template_schema(v, "object") if v.get("type") == "object" else v
+                    for k, v in properties.items()
+                },
+            }
+    return {**schema, "type": ty}
+
+
+def _positive_string(ctx: CoverageContext, schema: dict) -> Generator:
+    """Generate positive string values."""
+    # Boundary and near boundary values
+    min_length = schema.get("minLength")
+    max_length = schema.get("maxLength")
+
+    if not min_length and not max_length:
+        # Default positive value
+        yield ctx.generate_from_schema(schema)
+
+    seen = set()
+
+    if min_length is not None and min_length < BUFFER_SIZE and "pattern" not in schema:
+        # Exactly the minimum length
+        yield ctx.generate_from_schema({**schema, "maxLength": min_length})
+        seen.add(min_length)
+
+        # One character more than minimum if possible
+        larger = min_length + 1
+        if larger < BUFFER_SIZE and larger not in seen and (not max_length or larger <= max_length):
+            yield ctx.generate_from_schema({**schema, "minLength": larger, "maxLength": larger})
+            seen.add(larger)
+
+    if max_length is not None and "pattern" not in schema:
+        # Exactly the maximum length
+        if max_length < BUFFER_SIZE and max_length not in seen:
+            yield ctx.generate_from_schema({**schema, "minLength": max_length})
+            seen.add(max_length)
+
+        # One character less than maximum if possible
+        smaller = max_length - 1
+        if (
+            smaller < BUFFER_SIZE
+            and smaller not in seen
+            and (smaller > 0 and (min_length is None or smaller >= min_length))
+        ):
+            yield ctx.generate_from_schema({**schema, "minLength": smaller, "maxLength": smaller})
+            seen.add(smaller)
+
+
+def closest_multiple_greater_than(y: int, x: int) -> int:
+    """Find the closest multiple of X that is greater than Y."""
+    quotient, remainder = divmod(y, x)
+    if remainder == 0:
+        return y
+    return x * (quotient + 1)
+
+
+def _positive_number(ctx: CoverageContext, schema: dict) -> Generator:
+    """Generate positive integer values."""
+    # Boundary and near boundary values
+    minimum = schema.get("minimum")
+    maximum = schema.get("maximum")
+    exclusive_minimum = schema.get("exclusiveMinimum")
+    exclusive_maximum = schema.get("exclusiveMaximum")
+    if exclusive_minimum is not None:
+        minimum = exclusive_minimum + 1
+    if exclusive_maximum is not None:
+        maximum = exclusive_maximum - 1
+    multiple_of = schema.get("multipleOf")
+
+    if not minimum and not maximum:
+        # Default positive value
+        yield ctx.generate_from_schema(schema)
+
+    seen = set()
+
+    if minimum is not None:
+        # Exactly the minimum
+        if multiple_of is not None:
+            smallest = closest_multiple_greater_than(minimum, multiple_of)
+        else:
+            smallest = minimum
+        seen.add(smallest)
+        yield smallest
+
+        # One more than minimum if possible
+        if multiple_of is not None:
+            larger = smallest + multiple_of
+        else:
+            larger = minimum + 1
+        if larger not in seen and (not maximum or larger <= maximum):
+            seen.add(larger)
+            yield larger
+
+    if maximum is not None:
+        # Exactly the maximum
+        if multiple_of is not None:
+            largest = maximum - (maximum % multiple_of)
+        else:
+            largest = maximum
+        if largest not in seen:
+            seen.add(largest)
+            yield largest
+
+        # One less than maximum if possible
+        if multiple_of is not None:
+            smaller = largest - multiple_of
+        else:
+            smaller = maximum - 1
+        if smaller not in seen and (smaller > 0 and (minimum is None or smaller >= minimum)):
+            seen.add(smaller)
+            yield smaller
+
+
+def _positive_array(ctx: CoverageContext, schema: dict, template: list) -> Generator:
+    seen = set()
+    yield template
+    seen.add(len(template))
+
+    # Boundary and near-boundary sizes
+    min_items = schema.get("minItems")
+    max_items = schema.get("maxItems")
+    if min_items is not None:
+        # Do not generate an array with `minItems` length, because it is already covered by `template`
+
+        # One item more than minimum if possible
+        larger = min_items + 1
+        if larger not in seen and (max_items is None or larger <= max_items):
+            yield ctx.generate_from_schema({**schema, "minItems": larger, "maxItems": larger})
+            seen.add(larger)
+
+    if max_items is not None:
+        if max_items not in seen:
+            yield ctx.generate_from_schema({**schema, "minItems": max_items})
+            seen.add(max_items)
+
+        # One item smaller than maximum if possible
+        smaller = max_items - 1
+        if smaller > 0 and smaller not in seen and (min_items is None or smaller >= min_items):
+            yield ctx.generate_from_schema({**schema, "minItems": smaller, "maxItems": smaller})
+            seen.add(smaller)
+
+
+def _positive_object(ctx: CoverageContext, schema: dict, template: dict) -> Generator:
+    yield template
+    # Only required properties
+    properties = schema.get("properties", {})
+    if set(properties) != set(schema.get("required", {})):
+        only_required = {k: v for k, v in template.items() if k in schema.get("required", [])}
+        yield only_required
+    seen = set()
+    for name, sub_schema in properties.items():
+        seen.add(_to_hashable_key(template.get(name)))
+        for new in cover_schema_iter(ctx, sub_schema):
+            key = _to_hashable_key(new)
+            if key not in seen:
+                yield {**template, name: new}
+                seen.add(key)
+        seen.clear()
+
+
+@lru_cache(maxsize=128)
+def _get_negative_enum_strategy(value: tuple) -> st.SearchStrategy:
+    return JSON_STRATEGY.filter(lambda x: x not in value)
+
+
+def _negative_enum(ctx: CoverageContext, value: list) -> Generator:
+    try:
+        strategy = _get_negative_enum_strategy(tuple(value))
+    except TypeError:
+        # The value is not hashable
+        strategy = JSON_STRATEGY.filter(lambda x: x not in value)
+    # The exact negative value is not important here
+    yield ctx.generate_from(strategy, cached=True)
+
+
+def _negative_properties(ctx: CoverageContext, template: dict, properties: dict) -> Generator:
+    nctx = ctx.with_negative()
+    for key, sub_schema in properties.items():
+        for value in cover_schema_iter(nctx, sub_schema):
+            yield {**template, key: value}
+
+
+@lru_cache(maxsize=128)
+def _get_negative_pattern_strategy(value: str) -> st.SearchStrategy:
+    return st.text().filter(lambda x: x != value)
+
+
+def _negative_pattern(ctx: CoverageContext, pattern: str) -> Generator:
+    yield ctx.generate_from(_get_negative_pattern_strategy(pattern), cached=True)
+
+
+def _with_negated_key(schema: dict, key: str, value: Any) -> dict:
+    return {"allOf": [{k: v for k, v in schema.items() if k != key}, {"not": {key: value}}]}
+
+
+def _negative_multiple_of(ctx: CoverageContext, schema: dict, multiple_of: int | float) -> Generator:
+    yield ctx.generate_from_schema(_with_negated_key(schema, "multipleOf", multiple_of))
+
+
+def _negative_unique_items(ctx: CoverageContext, schema: dict) -> Generator:
+    unique = ctx.generate_from_schema({**schema, "type": "array", "minItems": 1, "maxItems": 1})
+    yield unique + unique
+
+
+def _negative_required(ctx: CoverageContext, template: dict, required: list[str]) -> Generator:
+    for key in required:
+        yield {k: v for k, v in template.items() if k != key}
+
+
+def _negative_format(ctx: CoverageContext, schema: dict, format: str) -> Generator:
+    # Hypothesis-jsonschema does not canonicalise it properly right now, which leads to unsatisfiable schema
+    without_format = {k: v for k, v in schema.items() if k != "format"}
+    without_format.setdefault("type", "string")
+    strategy = from_schema(without_format)
+    if format in jsonschema.Draft202012Validator.FORMAT_CHECKER.checkers:
+        strategy = strategy.filter(lambda v: not jsonschema.Draft202012Validator.FORMAT_CHECKER.conforms(v, format))
+    yield ctx.generate_from(strategy)
+
+
+def _negative_type(ctx: CoverageContext, seen: set, ty: str | list[str]) -> Generator:
+    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_)
+    if "number" in types:
+        del strategies["integer"]
+    if "integer" in types:
+        strategies["number"] = FLOAT_STRATEGY.filter(lambda x: x != int(x))
+    negative_strategy = combine_strategies(tuple(strategies.values())).filter(lambda x: _to_hashable_key(x) not in seen)
+    value = ctx.generate_from(negative_strategy, cached=True)
+    yield value
+    seen.add(_to_hashable_key(value))

schemathesis/schemas.py

@@ -50,6 +50,7 @@ from .generation import (
     DataGenerationMethod,
     DataGenerationMethodInput,
     GenerationConfig,
+    combine_strategies,
 )
 from .hooks import HookContext, HookDispatcher, HookScope, dispatch, to_filterable_hook
 from .internal.deprecation import warn_filtration_arguments
@@ -69,7 +70,7 @@ from .types import (
     PathParameters,
     Query,
 )
-from .utils import PARAMETRIZE_MARKER, GivenInput, combine_strategies, given_proxy
+from .utils import PARAMETRIZE_MARKER, GivenInput, given_proxy
 
 if TYPE_CHECKING:
     from .transports import Transport

schemathesis/service/extensions.py

@@ -128,7 +128,7 @@ def _apply_schema_patches_extension(extension: SchemaPatchesExtension, schema: B
 
 
 def strategy_from_definitions(definitions: list[StrategyDefinition]) -> Result[st.SearchStrategy, Exception]:
-    from ..utils import combine_strategies
+    from ..generation import combine_strategies
 
     strategies = []
     for definition in definitions:

schemathesis/specs/openapi/examples.py

@@ -10,8 +10,8 @@ import requests
 from hypothesis.strategies import SearchStrategy
 from hypothesis_jsonschema import from_schema
 
-from ..._hypothesis import get_single_example
 from ...constants import DEFAULT_RESPONSE_TIMEOUT
+from ...generation import get_single_example
 from ...internal.copy import fast_deepcopy
 from ...models import APIOperation, Case
 from ._hypothesis import get_case_strategy, get_default_format_strategies

schemathesis/specs/openapi/schemas.py

@@ -1032,6 +1032,7 @@ class SwaggerV20(BaseOpenAPISchema):
         query: Query | None = None,
         body: Body | NotSet = NOT_SET,
         media_type: str | None = None,
+        generation_time: float = 0.0,
     ) -> C:
         if body is not NOT_SET and media_type is None:
             media_type = operation._get_default_media_type()
@@ -1043,7 +1044,7 @@ class SwaggerV20(BaseOpenAPISchema):
             query=query,
             body=body,
             media_type=media_type,
-            generation_time=0.0,
+            generation_time=generation_time,
         )
 
     def _get_consumes_for_operation(self, definition: dict[str, Any]) -> list[str]:

schemathesis/specs/openapi/stateful/__init__.py

@@ -8,11 +8,10 @@ from hypothesis import strategies as st
 from hypothesis.stateful import Bundle, Rule, precondition, rule
 
 from ....constants import NOT_SET
-from ....generation import DataGenerationMethod
+from ....generation import DataGenerationMethod, combine_strategies
 from ....internal.result import Ok
 from ....stateful.state_machine import APIStateMachine, Direction, StepResult
 from ....types import NotSet
-from ....utils import combine_strategies
 from .. import expressions
 from ..links import get_all_links
 from ..utils import expand_status_code

schemathesis/utils.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import functools
-import operator
 from contextlib import contextmanager
 from inspect import getfullargspec
 from pathlib import Path
@@ -14,7 +13,6 @@ from typing import (
 )
 
 import pytest
-from hypothesis import strategies as st
 from hypothesis.core import is_invalid_test
 from hypothesis.reporting import with_reporter
 from hypothesis.strategies import SearchStrategy
@@ -149,14 +147,6 @@ def compose(*functions: Callable) -> Callable:
     return functools.reduce(lambda f, g: lambda x: f(g(x)), functions, noop)
 
 
-def combine_strategies(strategies: list[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 functools.reduce(operator.or_, strategies[1:], strategies[0])
-
-
 def skip(operation_name: str) -> NoReturn:
     raise SkipTest(f"It is not possible to generate negative test cases for `{operation_name}`")
 

{schemathesis-3.34.3.dist-info → schemathesis-3.35.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: schemathesis
-Version: 3.34.3
+Version: 3.35.0
 Summary: Property-based testing framework for Open API and GraphQL based apps
 Project-URL: Documentation, https://schemathesis.readthedocs.io/en/stable/
 Project-URL: Changelog, https://schemathesis.readthedocs.io/en/stable/changelog.html

{schemathesis-3.34.3.dist-info → schemathesis-3.35.0.dist-info}/RECORD

@@ -1,7 +1,7 @@
 schemathesis/__init__.py,sha256=pNaTfaC3NSdediNQuH9QAcuIx3U-MmSydvhS65FZrxw,1984
 schemathesis/_compat.py,sha256=y4RZd59i2NCnZ91VQhnKeMn_8t3SgvLOk2Xm8nymUHY,1837
 schemathesis/_dependency_versions.py,sha256=pjEkkGAfOQJYNb-9UOo84V8nj_lKHr_TGDVdFwY2UU0,816
-schemathesis/_hypothesis.py,sha256=Igb1x3am3tafVhZ6ikY7yrmQdNthC0PZFEYVCdNAA3w,11207
+schemathesis/_hypothesis.py,sha256=eLDbqhG2fBJ6DuTxXlRfadnHhFc3JE2P5zf0YS9UonQ,12782
 schemathesis/_lazy_import.py,sha256=aMhWYgbU2JOltyWBb32vnWBb6kykOghucEzI_F70yVE,470
 schemathesis/_override.py,sha256=3CbA7P9Q89W3ymaYxiOV5Xpv1yhoBqroLK4YRpYMjX4,1630
 schemathesis/_rate_limiter.py,sha256=q_XWst5hzuAyXQRiZc4s_bx7-JlPYZM_yKDmeavt3oo,242
@@ -21,34 +21,34 @@ schemathesis/models.py,sha256=WpF-W592_MVWnMZ8t7wt_A2fr3YNLEwPX3r-jwW8GpY,44266
 schemathesis/parameters.py,sha256=PndmqQRlEYsCt1kWjSShPsFf6vj7X_7FRdz_-A95eNg,2258
 schemathesis/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 schemathesis/sanitization.py,sha256=_qSt04f_XcHrgguyUnowvdfj-b6u409Ubu07i0ivQUQ,9011
-schemathesis/schemas.py,sha256=YXTWWM1JTFNQEKrxWPye1uQgm3I1_MQPBbc2Y4KW19o,20610
+schemathesis/schemas.py,sha256=nkcGcWsRCaT3wgx9vxyvluehqkWur7Fuhv8JAAu9AhY,20614
 schemathesis/serializers.py,sha256=kxXZ-UGa1v_vOm0sC4QYcrNv4rfvI7tHGT2elRVbCbc,11649
 schemathesis/targets.py,sha256=XIGRghvEzbmEJjse9aZgNEj67L3jAbiazm2rxURWgDE,2351
 schemathesis/throttling.py,sha256=aisUc4MJDGIOGUAs9L2DlWWpdd4KyAFuNVKhYoaUC9M,1719
 schemathesis/types.py,sha256=xOzNAeMs6qqeaJnWs5Fpw5JPbvVjyfRfxTJa3G2Ln5I,920
-schemathesis/utils.py,sha256=NX04p9mO-lCAH3DIISXDXPxWZk6lkGNM4-ubRi8vlvY,5234
-schemathesis/cli/__init__.py,sha256=ZxFkRvpRAaV5OuDZeHEeWrFTnVjJXX-w4cQfYe_R6Yw,73390
+schemathesis/utils.py,sha256=bYvB3l1iMxiUNHu7_1qhOj5gJf_8QUssL4Uoqgrux9A,4878
+schemathesis/cli/__init__.py,sha256=O2VIpE9EWFrklWlVTTFUQGShxN8Ij9nbaOJFslDEmHY,73976
 schemathesis/cli/__main__.py,sha256=MWaenjaUTZIfNPFzKmnkTiawUri7DVldtg3mirLwzU8,92
 schemathesis/cli/callbacks.py,sha256=PJs64n6qGrGC5Yv_yl3fGm797cvN6pp2enFLmSljGKs,15127
 schemathesis/cli/cassettes.py,sha256=lKKKKLjoVT8VnZXjCOCmDYhvLKn1XSrCXCMF9EeftHA,18498
 schemathesis/cli/constants.py,sha256=wk-0GsoJIel8wFFerQ6Kf_6eAYUtIWkwMFwyAqv3yj4,1635
-schemathesis/cli/context.py,sha256=EMeyAbU9mRujR46anc43yr6ab4rGYtIDaHC3cV9Qa-Q,2092
+schemathesis/cli/context.py,sha256=6OYpSbeRobkdyDGvSj_2_zwEelM9K6fXpUCUjVC2sQM,2243
 schemathesis/cli/debug.py,sha256=_YA-bX1ujHl4bqQDEum7M-I2XHBTEGbvgkhvcvKhmgU,658
-schemathesis/cli/handlers.py,sha256=RjvogPCqqFTiyVYWrGG6euw9-6h-7uSeFvS-ouU8eWs,389
+schemathesis/cli/handlers.py,sha256=EXSAFe5TQlHANz1AVlSttfsoDT2oeaeFbqq1N7e2udw,467
 schemathesis/cli/junitxml.py,sha256=FeQbgjYYwD0twk1QSbP3AivLPhHGwIuikQ6CN2Kw9ho,5050
 schemathesis/cli/options.py,sha256=DY5PUzpUNyYgpcqqFTeZjmVUykpbaI9fbN44QIWNOfA,2559
 schemathesis/cli/reporting.py,sha256=zNKaRAUfDZ23-gMtiWbnG2OBndkYlM7ljKvk0Mc_lqI,3589
 schemathesis/cli/sanitization.py,sha256=Onw_NWZSom6XTVNJ5NHnC0PAhrYAcGzIXJbsBCzLkn4,1005
 schemathesis/cli/output/__init__.py,sha256=AXaUzQ1nhQ-vXhW4-X-91vE2VQtEcCOrGtQXXNN55iQ,29
-schemathesis/cli/output/default.py,sha256=nYuUwm2M3pIsDebofgXuIFb7Vl4t4sLO0PKmJcE6tb8,39385
+schemathesis/cli/output/default.py,sha256=VrV5I4PYaZPiKzbuJXmDL2PtcPUDoWxbb6pC1ShgjJ8,39508
 schemathesis/cli/output/short.py,sha256=CL6-Apxr5tuZ3BL1vecV1MiRY1wDt21g0wiUwZu6mLM,2607
 schemathesis/contrib/__init__.py,sha256=FH8NL8NXgSKBFOF8Jy_EB6T4CJEaiM-tmDhz16B2o4k,187
 schemathesis/contrib/unique_data.py,sha256=_ElPRLNp0XhdETiZ-aplKln4hgU04jxR17kmjAEWf1I,1318
 schemathesis/contrib/openapi/__init__.py,sha256=N-BoCzrLGq9aynubhmQBS-LJUBv1wPJcveMCJDhyQl4,217
-schemathesis/contrib/openapi/fill_missing_examples.py,sha256=vXImJkXj1UHkytsciQrmkuNu3AnTYzwrR_gODf6ObOA,584
+schemathesis/contrib/openapi/fill_missing_examples.py,sha256=SL3LXG4khjGKneU3aBu1MGIhYtwRMjK77NH8L--9JBE,583
 schemathesis/contrib/openapi/formats/__init__.py,sha256=OpHWPW8MkTLVv83QXPYY1HVLflhmSH49hSVefm1oVV0,111
 schemathesis/contrib/openapi/formats/uuid.py,sha256=PG7aV0QAQnQ1zKmKiDK3cJue3Xy-TLGzyMeCB_RQbgk,391
-schemathesis/experimental/__init__.py,sha256=IyXUjRRbZWlj3V702bZNu-fmMgt1XHSihJHw4XrF-VI,2880
+schemathesis/experimental/__init__.py,sha256=vza-jHjFAdyrnOBWVkiXyQi2Q7HoTUM9Zs3E7ozJmog,3161
 schemathesis/extra/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 schemathesis/extra/_aiohttp.py,sha256=-bIY0ucv7pfK3gA9PHiO4n7ajtZJJM9pS3EY3cLau9c,957
 schemathesis/extra/_flask.py,sha256=BHCbxBDoMlIvNS5sRNyrPN1NwHxiDQt0IsyfYwwoFes,289
@@ -57,7 +57,10 @@ schemathesis/extra/pytest_plugin.py,sha256=ymicV2NjmSzee0ccUUUjNEvb9ihCxxf_8M60g
 schemathesis/fixups/__init__.py,sha256=RP5QYJVJhp8LXjhH89fCRaIVU26dHCy74jD9seoYMuc,967
 schemathesis/fixups/fast_api.py,sha256=mn-KzBqnR8jl4W5fY-_ZySabMDMUnpzCIESMHnlvE1c,1304
 schemathesis/fixups/utf8_bom.py,sha256=lWT9RNmJG8i-l5AXIpaCT3qCPUwRgzXPW3eoOjmZETA,745
-schemathesis/generation/__init__.py,sha256=wUd5HqIh96Aw91Un0rLOd3XXi2E3BXedSMMjS5RXkuo,2472
+schemathesis/generation/__init__.py,sha256=IzldWIswXBjCUaVInvXDoaXIrUbtZIU5cisnWcg2IX8,1609
+schemathesis/generation/_hypothesis.py,sha256=Qel0mBsZV6tOEspRGfbJKFZevaMgHJjzY1F0Oo1bP_Y,1408
+schemathesis/generation/_methods.py,sha256=jCK09f4sedDfePrS-6BIiE-CcEE8fJ4ZHxq1BHoTltQ,1101
+schemathesis/generation/coverage.py,sha256=_g4jcuNTZ7emudQklcHcnkwNZeP1QBo1smNkGZHeCMo,17176
 schemathesis/internal/__init__.py,sha256=93HcdG3LF0BbQKbCteOsFMa1w6nXl8yTmx87QLNJOik,161
 schemathesis/internal/copy.py,sha256=DcL56z-d69kKR_5u8mlHvjSL1UTyUKNMAwexrwHFY1s,1031
 schemathesis/internal/datetime.py,sha256=zPLBL0XXLNfP-KYel3H2m8pnsxjsA_4d-zTOhJg2EPQ,136
@@ -82,7 +85,7 @@ schemathesis/service/ci.py,sha256=3m9xSWFhrpWA6mI_8bXI7sspND9RSqXFM9UseO5nIiM,67
 schemathesis/service/client.py,sha256=Mpm90O59GctKVw38OcV7F99a8VzsL_Z5AT-dDkn25hc,5218
 schemathesis/service/constants.py,sha256=Q1bhtLRkmhso4KSVAtWl0u446Wlbk3ShOL3ZdbPoJOM,1502
 schemathesis/service/events.py,sha256=zgELQFB-ir8yzK1G-a5BDOyxrISuXKUQ72fIBKIdgJY,1238
-schemathesis/service/extensions.py,sha256=ClgL87obAMo_K4yexp2rqIuSNEpUyfhlE6OyRBMVY0U,7827
+schemathesis/service/extensions.py,sha256=uU87ewgtdq610TvCRELsgFqt0YLSFb3dAHXlB0ZDQ_w,7832
 schemathesis/service/hosts.py,sha256=ad2Lxq9Zcc9PP-1eFLQnxen4ImglcGOH8n7CGG72NNg,3123
 schemathesis/service/metadata.py,sha256=x2LeCED1mdPf-YQJmjY8xtcIKHfD1ap5V0BGl-UgqNo,2087
 schemathesis/service/models.py,sha256=ihItUJ9CvH4TvmdfJY3W88NR82OODF8a3RD7WRXn6RM,6578
@@ -104,14 +107,14 @@ schemathesis/specs/openapi/checks.py,sha256=LiwoL5W_qK40j-JFSc9hfM8IGSszMBUWe71Y
 schemathesis/specs/openapi/constants.py,sha256=JqM_FHOenqS_MuUE9sxVQ8Hnw0DNM8cnKDwCwPLhID4,783
 schemathesis/specs/openapi/converter.py,sha256=TaYgc5BBHPdkN-n0lqpbeVgLu3eL3L8Wu3y_Vo3TJaQ,2800
 schemathesis/specs/openapi/definitions.py,sha256=Z186F0gNBSCmPg-Kk7Q-n6XxEZHIOzgUyeqixlC62XE,94058
-schemathesis/specs/openapi/examples.py,sha256=ElfX1kZ4XWfOSOVbes_ovy4P6q_NgWpa0RF0rNJLVM4,16170
+schemathesis/specs/openapi/examples.py,sha256=aE1OsR4X6OBSgRnFD0mVB2aQ3mWe65xiL2YsLb6xkeU,16169
 schemathesis/specs/openapi/formats.py,sha256=JmmkQWNAj5XreXb7Edgj4LADAf4m86YulR_Ec8evpJ4,1220
 schemathesis/specs/openapi/links.py,sha256=DCOu14VOFqKYYFbQJHWICDpmTBzJfeP2v2FXBwW3vBI,17531
 schemathesis/specs/openapi/loaders.py,sha256=AcpvTK8qdirSRcHcinCjQbwfSQSx448LAh_GvFML1C0,25515
 schemathesis/specs/openapi/media_types.py,sha256=dNTxpRQbY3SubdVjh4Cjb38R6Bc9MF9BsRQwPD87x0g,1017
 schemathesis/specs/openapi/parameters.py,sha256=_6vNCnPXcdxjfAQbykCRLHjvmTpu_02xDJghxDrGYr8,13611
 schemathesis/specs/openapi/references.py,sha256=euxM02kQGMHh4Ss1jWjOY_gyw_HazafKITIsvOEiAvI,9831
-schemathesis/specs/openapi/schemas.py,sha256=c732S1iDo-Ns-mw8xfRn98KXzhE6bgmgYk9KN9lTqhc,53003
+schemathesis/specs/openapi/schemas.py,sha256=3pZEAU9sB9PT32z3BhJPsSSR0wVpJXL20-z9hMWS52s,53053
 schemathesis/specs/openapi/security.py,sha256=nEhDB_SvEFldmfpa9uOQywfWN6DtXHKmgtwucJvfN5Q,7096
 schemathesis/specs/openapi/serialization.py,sha256=5qGdFHZ3n80UlbSXrO_bkr4Al_7ci_Z3aSUjZczNDQY,11384
 schemathesis/specs/openapi/utils.py,sha256=-TCu0hTrlwp2x5qHNp-TxiHRMeIZC9OBmlhLssjRIiQ,742
@@ -127,7 +130,7 @@ schemathesis/specs/openapi/negative/__init__.py,sha256=gw0w_9tVQf_MY5Df3_xTZFC4r
 schemathesis/specs/openapi/negative/mutations.py,sha256=lLEN0GLxvPmZBQ3tHCznDSjmZ4yQiQxspjv1UpO4Kx0,19019
 schemathesis/specs/openapi/negative/types.py,sha256=a7buCcVxNBG6ILBM3A7oNTAX0lyDseEtZndBuej8MbI,174
 schemathesis/specs/openapi/negative/utils.py,sha256=ozcOIuASufLqZSgnKUACjX-EOZrrkuNdXX0SDnLoGYA,168
-schemathesis/specs/openapi/stateful/__init__.py,sha256=wI9WCuHW0EBTUeBaClWi48I6J63TiczBX6UiErsmbB4,9470
+schemathesis/specs/openapi/stateful/__init__.py,sha256=N-Rg9kPuDFAYu8quZbiRe8P1Qd3jz3wjMsIN19nSrhk,9449
 schemathesis/specs/openapi/stateful/statistic.py,sha256=EJK4NqeAYRYl1FtU9YEuTLyhGhPmks0bLoxUPuQlOvM,7443
 schemathesis/specs/openapi/stateful/types.py,sha256=UuGcCTFvaHsqeLN9ZeUNcbjsEwmthoT3UcHfDHchOYo,419
 schemathesis/stateful/__init__.py,sha256=gONzl3pgZ8DihjK52Wd3Ye1LeP6gnulmevHI_jEqHWI,5088
@@ -144,8 +147,8 @@ schemathesis/transports/auth.py,sha256=yELjkEkfx4g74hNrd0Db9aFf0xDJDRIwhg2vzKOTZ
 schemathesis/transports/content_types.py,sha256=VrcRQvF5T_TUjrCyrZcYF2LOwKfs3IrLcMtkVSp1ImI,2189
 schemathesis/transports/headers.py,sha256=hr_AIDOfUxsJxpHfemIZ_uNG3_vzS_ZeMEKmZjbYiBE,990
 schemathesis/transports/responses.py,sha256=6-gvVcRK0Ho_lSydUysBNFWoJwZEiEgf6Iv-GWkQGd8,1675
-schemathesis-3.34.3.dist-info/METADATA,sha256=PsAgyQEs6iPW3VV5P_9r1zRAcw9WDnCsD4CbSieLWoM,19287
-schemathesis-3.34.3.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-schemathesis-3.34.3.dist-info/entry_points.txt,sha256=VHyLcOG7co0nOeuk8WjgpRETk5P1E2iCLrn26Zkn5uk,158
-schemathesis-3.34.3.dist-info/licenses/LICENSE,sha256=PsPYgrDhZ7g9uwihJXNG-XVb55wj2uYhkl2DD8oAzY0,1103
-schemathesis-3.34.3.dist-info/RECORD,,
+schemathesis-3.35.0.dist-info/METADATA,sha256=hljiaQNfbUOdt0Dt5mIuOUzyd_Qn4gkFJDWhW2gIev8,19287
+schemathesis-3.35.0.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+schemathesis-3.35.0.dist-info/entry_points.txt,sha256=VHyLcOG7co0nOeuk8WjgpRETk5P1E2iCLrn26Zkn5uk,158
+schemathesis-3.35.0.dist-info/licenses/LICENSE,sha256=PsPYgrDhZ7g9uwihJXNG-XVb55wj2uYhkl2DD8oAzY0,1103
+schemathesis-3.35.0.dist-info/RECORD,,