schemathesis 3.39.10__py3-none-any.whl → 3.39.12__py3-none-any.whl

schemathesis/_hypothesis.py

@@ -4,7 +4,6 @@ from __future__ import annotations
 
 import asyncio
 from dataclasses import dataclass
-import json
 import warnings
 from functools import wraps
 from itertools import combinations
@@ -16,8 +15,10 @@ from hypothesis.errors import HypothesisWarning, Unsatisfiable
 from hypothesis.internal.entropy import deterministic_PRNG
 from jsonschema.exceptions import SchemaError
 
+from schemathesis.serializers import get_first_matching_media_type
+
 from . import _patches
-from .auths import get_auth_storage_from_test
+from .auths import AuthStorage, get_auth_storage_from_test
 from .constants import DEFAULT_DEADLINE, NOT_SET
 from .exceptions import OperationSchemaError, SerializationNotPossible
 from .experimental import COVERAGE_PHASE
@@ -28,6 +29,7 @@ from .parameters import ParameterSet
 from .transports.content_types import parse_content_type
 from .transports.headers import has_invalid_characters, is_latin_1_encodable
 from .types import NotSet
+from schemathesis import auths
 
 if TYPE_CHECKING:
     from .utils import GivenInput
@@ -112,7 +114,15 @@ def create_test(
                 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)
+                unexpected_methods = generation_config.unexpected_methods if generation_config else None
+                wrapped_test = add_coverage(
+                    wrapped_test,
+                    operation,
+                    data_generation_methods,
+                    auth_storage,
+                    as_strategy_kwargs,
+                    unexpected_methods,
+                )
     return wrapped_test
 
 
@@ -216,20 +226,46 @@ def adjust_urlencoded_payload(case: Case) -> None:
 
 
 def add_coverage(
-    test: Callable, operation: APIOperation, data_generation_methods: list[DataGenerationMethod]
+    test: Callable,
+    operation: APIOperation,
+    data_generation_methods: list[DataGenerationMethod],
+    auth_storage: AuthStorage | None,
+    as_strategy_kwargs: dict[str, Any],
+    unexpected_methods: set[str] | None = None,
 ) -> Callable:
-    for example in _iter_coverage_cases(operation, data_generation_methods):
-        adjust_urlencoded_payload(example)
-        test = hypothesis.example(case=example)(test)
+    from schemathesis.specs.openapi.constants import LOCATION_TO_CONTAINER
+
+    auth_context = auths.AuthContext(
+        operation=operation,
+        app=operation.app,
+    )
+    overrides = {
+        container: as_strategy_kwargs[container]
+        for container in LOCATION_TO_CONTAINER.values()
+        if container in as_strategy_kwargs
+    }
+    for case in _iter_coverage_cases(operation, data_generation_methods, unexpected_methods):
+        if case.media_type and get_first_matching_media_type(case.media_type) is None:
+            continue
+        adjust_urlencoded_payload(case)
+        auths.set_on_case(case, auth_context, auth_storage)
+        for container_name, value in overrides.items():
+            container = getattr(case, container_name)
+            if container is None:
+                setattr(case, container_name, value)
+            else:
+                container.update(value)
+        test = hypothesis.example(case=case)(test)
     return test
 
 
 class Template:
-    __slots__ = ("_components", "_template")
+    __slots__ = ("_components", "_template", "_serializers")
 
-    def __init__(self) -> None:
+    def __init__(self, serializers: dict[str, Callable]) -> None:
         self._components: dict[str, DataGenerationMethod] = {}
         self._template: dict[str, Any] = {}
+        self._serializers = serializers
 
     def __contains__(self, key: str) -> bool:
         return key in self._template
@@ -251,36 +287,58 @@ class Template:
             self._components[component_name] = DataGenerationMethod.negative
 
         container = self._template.setdefault(component_name, {})
-        if _should_stringify(location, value):
-            container[name] = _stringify_value(value.value, location)
-        else:
-            container[name] = value.value
+        container[name] = value.value
 
     def set_body(self, body: coverage.GeneratedValue, media_type: str) -> None:
         self._template["body"] = body.value
         self._template["media_type"] = media_type
         self._components["body"] = body.data_generation_method
 
+    def _serialize(self, kwargs: dict[str, Any]) -> dict[str, Any]:
+        from schemathesis.specs.openapi._hypothesis import quote_all
+
+        output = {}
+        for container_name, value in kwargs.items():
+            serializer = self._serializers.get(container_name)
+            if container_name in ("headers", "cookies") and isinstance(value, dict):
+                value = _stringify_value(value, container_name)
+            if serializer is not None:
+                value = serializer(value)
+            if container_name == "query" and isinstance(value, dict):
+                value = _stringify_value(value, container_name)
+            if container_name == "path_parameters" and isinstance(value, dict):
+                value = _stringify_value(quote_all(value), container_name)
+            output[container_name] = value
+        return output
+
     def unmodified(self) -> TemplateValue:
-        return TemplateValue(kwargs=self._template.copy(), components=self._components.copy())
+        kwargs = self._template.copy()
+        kwargs = self._serialize(kwargs)
+        return TemplateValue(kwargs=kwargs, components=self._components.copy())
 
     def with_body(self, *, media_type: str, value: coverage.GeneratedValue) -> TemplateValue:
         kwargs = {**self._template, "media_type": media_type, "body": value.value}
+        kwargs = self._serialize(kwargs)
         components = {**self._components, "body": value.data_generation_method}
         return TemplateValue(kwargs=kwargs, components=components)
 
     def with_parameter(self, *, location: str, name: str, value: coverage.GeneratedValue) -> TemplateValue:
         from .specs.openapi.constants import LOCATION_TO_CONTAINER
 
-        if _should_stringify(location, value):
-            generated = _stringify_value(value.value, location)
-        else:
-            generated = value.value
-
         container_name = LOCATION_TO_CONTAINER[location]
         container = self._template[container_name]
-        kwargs = {**self._template, container_name: {**container, name: generated}}
-        components = {**self._components, container_name: value.data_generation_method}
+        return self.with_container(
+            container_name=container_name,
+            value={**container, name: value.value},
+            data_generation_method=value.data_generation_method,
+        )
+
+    def with_container(
+        self, *, container_name: str, value: Any, data_generation_method: DataGenerationMethod
+    ) -> TemplateValue:
+        kwargs = {**self._template, container_name: value}
+        kwargs = self._serialize(kwargs)
+        components = {**self._components, container_name: data_generation_method}
         return TemplateValue(kwargs=kwargs, components=components)
 
 
@@ -291,38 +349,41 @@ class TemplateValue:
     __slots__ = ("kwargs", "components")
 
 
-def _should_stringify(location: str, value: coverage.GeneratedValue) -> bool:
-    return location in ("header", "cookie", "path", "query") and not isinstance(value.value, str)
-
-
-def _stringify_value(val: Any, location: str) -> str | list[str]:
+def _stringify_value(val: Any, container_name: str) -> Any:
+    if val is None:
+        return "null"
+    if val is True:
+        return "true"
+    if val is False:
+        return "false"
+    if isinstance(val, (int, float)):
+        return str(val)
     if isinstance(val, list):
-        if location == "query":
+        if container_name == "query":
             # Having a list here ensures there will be multiple query parameters wit the same name
-            return [json.dumps(item) for item in val]
+            return [_stringify_value(item, container_name) for item in val]
         # use comma-separated values style for arrays
-        return ",".join(json.dumps(sub) for sub in val)
-    return json.dumps(val)
+        return ",".join(_stringify_value(sub, container_name) for sub in val)
+    if isinstance(val, dict):
+        return {key: _stringify_value(sub, container_name) for key, sub in val.items()}
+    return val
 
 
 def _iter_coverage_cases(
-    operation: APIOperation, data_generation_methods: list[DataGenerationMethod]
+    operation: APIOperation,
+    data_generation_methods: list[DataGenerationMethod],
+    unexpected_methods: set[str] | None = None,
 ) -> 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)
+    from schemathesis.specs.openapi.serialization import get_serializers_for_operation
 
     generators: dict[tuple[str, str], Generator[coverage.GeneratedValue, None, None]] = {}
-    template = Template()
+    serializers = get_serializers_for_operation(operation)
+    template = Template(serializers)
     responses = find_in_responses(operation)
+    # NOTE: The HEAD method is excluded
+    unexpected_methods = unexpected_methods or {"get", "put", "post", "delete", "options", "patch", "trace"}
     for parameter in operation.iter_parameters():
         location = parameter.location
         name = parameter.name
@@ -398,8 +459,7 @@ def _iter_coverage_cases(
             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])
+        methods = unexpected_methods - set(operation.schema[operation.path])
         for method in sorted(methods):
             data = template.unmodified()
             case = operation.make_case(**data.kwargs)
@@ -415,10 +475,12 @@ def _iter_coverage_cases(
                 # I.e. contains just `default` value without any other keywords
                 value = container.get(parameter.name, NOT_SET)
                 if value is not NOT_SET:
-                    data = template.unmodified()
-                    case = operation.make_case(
-                        **{**data.kwargs, "query": {**container, parameter.name: [value, value]}}
+                    data = template.with_container(
+                        container_name="query",
+                        value={**container, parameter.name: [value, value]},
+                        data_generation_method=DataGenerationMethod.negative,
                     )
+                    case = operation.make_case(**data.kwargs)
                     case.data_generation_method = DataGenerationMethod.negative
                     case.meta = _make_meta(
                         description=f"Duplicate `{parameter.name}` query parameter",
@@ -435,17 +497,19 @@ def _iter_coverage_cases(
                 location = parameter.location
                 container_name = LOCATION_TO_CONTAINER[location]
                 container = template[container_name]
-                data = template.unmodified()
-                case = operation.make_case(
-                    **{**data.kwargs, container_name: {k: v for k, v in container.items() if k != name}}
+                data = template.with_container(
+                    container_name=container_name,
+                    value={k: v for k, v in container.items() if k != name},
+                    data_generation_method=DataGenerationMethod.negative,
                 )
+                case = operation.make_case(**data.kwargs)
                 case.data_generation_method = DataGenerationMethod.negative
                 case.meta = _make_meta(
                     description=f"Missing `{name}` at {location}",
                     location=None,
                     parameter=name,
                     parameter_location=location,
-                    **{**data.components, container_name: DataGenerationMethod.negative},
+                    **data.components,
                 )
                 yield case
     # Generate combinations for each location
@@ -474,23 +538,17 @@ def _iter_coverage_cases(
             _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
-
-            data = template.unmodified()
-            case = operation.make_case(**{**data.kwargs, _container_name: container})
+            data = template.with_container(
+                container_name=_container_name, value=container_values, data_generation_method=_data_generation_method
+            )
+            case = operation.make_case(**data.kwargs)
             case.data_generation_method = _data_generation_method
             case.meta = _make_meta(
                 description=description,
                 location=None,
                 parameter=_parameter,
                 parameter_location=_location,
-                **{**data.components, _container_name: _data_generation_method},
+                **data.components,
             )
             return case
 

schemathesis/cli/__init__.py

@@ -9,7 +9,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, Type, cast
+from typing import TYPE_CHECKING, Any, Callable, Generator, Iterable, Literal, NoReturn, Sequence, cast
 from urllib.parse import urlparse
 
 import click
@@ -27,6 +27,7 @@ from ..constants import (
     DEFAULT_STATEFUL_RECURSION_LIMIT,
     EXTENSIONS_DOCUMENTATION_URL,
     HOOKS_MODULE_ENV_VAR,
+    HTTP_METHODS,
     HYPOTHESIS_IN_MEMORY_DATABASE_IDENTIFIER,
     ISSUE_TRACKER_URL,
     WAIT_FOR_SCHEMA_ENV_VAR,
@@ -323,6 +324,16 @@ REPORT_TO_SERVICE = ReportToService()
     multiple=True,
     metavar="",
 )
+@grouped_option(
+    "--experimental-coverage-unexpected-methods",
+    "coverage_unexpected_methods",
+    help="HTTP methods to use when generating test cases with methods not specified in the API during the coverage phase.",
+    type=CsvChoice(sorted(HTTP_METHODS), case_sensitive=False),
+    callback=callbacks.convert_http_methods,
+    metavar="",
+    default=None,
+    envvar="SCHEMATHESIS_EXPERIMENTAL_COVERAGE_UNEXPECTED_METHODS",
+)
 @grouped_option(
     "--experimental-no-failfast",
     "no_failfast",
@@ -874,6 +885,7 @@ def run(
     set_path: dict[str, str],
     experiments: list,
     no_failfast: bool,
+    coverage_unexpected_methods: set[str] | None,
     missing_required_header_allowed_statuses: list[str],
     positive_data_acceptance_allowed_statuses: list[str],
     negative_data_rejection_allowed_statuses: list[str],
@@ -1000,6 +1012,7 @@ def run(
         graphql_allow_null=generation_graphql_allow_null,
         codec=generation_codec,
         with_security_parameters=generation_with_security_parameters,
+        unexpected_methods=coverage_unexpected_methods,
     )
 
     report: ReportToService | click.utils.LazyFile | None

schemathesis/cli/callbacks.py

@@ -344,6 +344,14 @@ def convert_checks(ctx: click.core.Context, param: click.core.Parameter, value:
     return reduce(operator.iadd, value, [])
 
 
+def convert_http_methods(
+    ctx: click.core.Context, param: click.core.Parameter, value: list[str] | None
+) -> set[str] | None:
+    if value is None:
+        return value
+    return {item.lower() for item in value}
+
+
 def convert_status_codes(
     ctx: click.core.Context, param: click.core.Parameter, value: list[str] | None
 ) -> list[str] | None:

schemathesis/cli/options.py

@@ -26,7 +26,12 @@ class CustomHelpMessageChoice(click.Choice):
 class BaseCsvChoice(click.Choice):
     def parse_value(self, value: str) -> tuple[list[str], set[str]]:
         selected = [item for item in value.split(",") if item]
-        invalid_options = set(selected) - set(self.choices)
+        if not self.case_sensitive:
+            invalid_options = {
+                item for item in selected if item.upper() not in {choice.upper() for choice in self.choices}
+            }
+        else:
+            invalid_options = set(selected) - set(self.choices)
         return selected, invalid_options
 
     def fail_on_invalid_options(self, invalid_options: set[str], selected: list[str]) -> NoReturn:

schemathesis/failures.py

@@ -143,6 +143,12 @@ class AcceptedNegativeData(FailureContext):
     title: str = "Accepted negative data"
     type: str = "accepted_negative_data"
 
+    def unique_by_key(self, check_message: str | None) -> tuple[str, ...]:
+        return (
+            check_message or self.message,
+            str(self.status_code),
+        )
+
 
 @dataclass(repr=False)
 class RejectedPositiveData(FailureContext):

schemathesis/generation/__init__.py

@@ -50,3 +50,4 @@ class GenerationConfig:
     with_security_parameters: bool = True
     # Header generation configuration
     headers: HeaderConfig = field(default_factory=HeaderConfig)
+    unexpected_methods: set[str] | None = None

schemathesis/internal/checks.py

@@ -21,7 +21,9 @@ CheckFunction = Callable[["CheckContext", "GenericResponse", "Case"], Optional[b
 @dataclass
 class NegativeDataRejectionConfig:
     # 5xx will pass through
-    allowed_statuses: list[str] = field(default_factory=lambda: ["400", "401", "403", "404", "422", "428", "5xx"])
+    allowed_statuses: list[str] = field(
+        default_factory=lambda: ["400", "401", "403", "404", "406", "422", "428", "5xx"]
+    )
 
 
 @dataclass

schemathesis/runner/impl/core.py

@@ -150,13 +150,6 @@ class BaseRunner:
         def _should_warn_about_only_4xx(result: TestResult) -> bool:
             if all(check.response is None for check in result.checks):
                 return False
-            # Don't warn if we saw any 2xx or 5xx responses
-            if any(
-                check.response.status_code < 400 or check.response.status_code >= 500
-                for check in result.checks
-                if check.response is not None
-            ):
-                return False
             # Don't duplicate auth warnings
             if {check.response.status_code for check in result.checks if check.response is not None} <= {401, 403}:
                 return False
@@ -164,11 +157,28 @@ class BaseRunner:
             return True
 
         def _check_warnings() -> None:
+            # Warn if all positive test cases got 4xx in return and no failure was found
+            def all_positive_are_rejected(result: TestResult) -> bool:
+                seen_positive = False
+                for check in result.checks:
+                    if check.example.data_generation_method != DataGenerationMethod.positive:
+                        continue
+                    seen_positive = True
+                    if check.response is None:
+                        continue
+                    # At least one positive response for positive test case
+                    if 200 <= check.response.status_code < 300:
+                        return False
+                # If there are positive test cases, and we ended up here, then there are no 2xx responses for them
+                # Otherwise, there are no positive test cases at all and this check should pass
+                return seen_positive
+
             for result in ctx.data.results:
                 # Only warn about 4xx responses in successful positive test scenarios
                 if (
                     all(check.value == Status.success for check in result.checks)
-                    and result.data_generation_method == [DataGenerationMethod.positive]
+                    and DataGenerationMethod.positive in result.data_generation_method
+                    and all_positive_are_rejected(result)
                     and _should_warn_about_only_4xx(result)
                 ):
                     ctx.add_warning(

schemathesis/specs/openapi/checks.py

@@ -294,7 +294,12 @@ def missing_required_header(ctx: CheckContext, response: GenericResponse, case:
 
 
 def unsupported_method(ctx: CheckContext, response: GenericResponse, case: Case) -> bool | None:
-    if case.meta and case.meta.description and case.meta.description.startswith("Unspecified HTTP method:"):
+    if (
+        case.meta
+        and case.meta.description
+        and case.meta.description.startswith("Unspecified HTTP method:")
+        and response.request.method != "OPTIONS"
+    ):
         if response.status_code != 405:
             raise AssertionError(
                 f"Unexpected response status for unspecified HTTP method: {response.status_code}\nExpected: 405"

schemathesis/specs/openapi/examples.py

@@ -9,6 +9,8 @@ from typing import TYPE_CHECKING, Any, Generator, Iterator, Union, cast
 import requests
 from hypothesis_jsonschema import from_schema
 
+from schemathesis.specs.openapi.serialization import get_serializers_for_operation
+
 from ...constants import DEFAULT_RESPONSE_TIMEOUT
 from ...generation import get_single_example
 from ...internal.copy import fast_deepcopy
@@ -48,11 +50,7 @@ def get_strategies_from_examples(
     operation: APIOperation[OpenAPIParameter, Case], as_strategy_kwargs: dict[str, Any] | None = None
 ) -> list[SearchStrategy[Case]]:
     """Build a set of strategies that generate test cases based on explicit examples in the schema."""
-    maps = {}
-    for location, container in LOCATION_TO_CONTAINER.items():
-        serializer = operation.get_parameter_serializer(location)
-        if serializer is not None:
-            maps[container] = serializer
+    maps = get_serializers_for_operation(operation)
 
     def serialize_components(case: Case) -> Case:
         """Applies special serialization rules for case components.

schemathesis/specs/openapi/patterns.py

@@ -3,6 +3,8 @@ from __future__ import annotations
 import re
 from functools import lru_cache
 
+from ...exceptions import InternalError
+
 try:  # pragma: no cover
     import re._constants as sre
     import re._parser as sre_parse
@@ -29,7 +31,15 @@ def update_quantifier(pattern: str, min_length: int | None, max_length: int | No
 
     try:
         parsed = sre_parse.parse(pattern)
-        return _handle_parsed_pattern(parsed, pattern, min_length, max_length)
+        updated = _handle_parsed_pattern(parsed, pattern, min_length, max_length)
+        try:
+            re.compile(updated)
+        except re.error as exc:
+            raise InternalError(
+                f"The combination of min_length={min_length} and max_length={max_length} applied to the original pattern '{pattern}' resulted in an invalid regex: '{updated}'. "
+                "This indicates a bug in the regex quantifier merging logic"
+            ) from exc
+        return updated
     except re.error:
         # Invalid pattern
         return pattern
@@ -114,6 +124,21 @@ def _handle_anchored_pattern(parsed: list, pattern: str, min_length: int | None,
 
     for op, value in pattern_parts:
         if op == LITERAL:
+            # Check if the literal comes from a bracketed expression,
+            # e.g. Python regex parses "[+]" as a single LITERAL token.
+            if pattern[current_position] == "[":
+                # Find the matching closing bracket.
+                end_idx = current_position + 1
+                while end_idx < len(pattern):
+                    # Check for an unescaped closing bracket.
+                    if pattern[end_idx] == "]" and (end_idx == current_position + 1 or pattern[end_idx - 1] != "\\"):
+                        end_idx += 1
+                        break
+                    end_idx += 1
+                # Append the entire character set.
+                result += pattern[current_position:end_idx]
+                current_position = end_idx
+                continue
             if pattern[current_position] == "\\":
                 # Escaped value
                 current_position += 2
@@ -261,13 +286,18 @@ def _handle_repeat_quantifier(
     min_length, max_length = _build_size(min_repeat, max_repeat, min_length, max_length)
     if min_length > max_length:
         return pattern
-    return f"({_strip_quantifier(pattern).strip(')(')})" + _build_quantifier(min_length, max_length)
+    inner = _strip_quantifier(pattern)
+    if inner.startswith("(") and inner.endswith(")"):
+        inner = inner[1:-1]
+    return f"({inner})" + _build_quantifier(min_length, max_length)
 
 
 def _handle_literal_or_in_quantifier(pattern: str, min_length: int | None, max_length: int | None) -> str:
     """Handle literal or character class quantifiers."""
     min_length = 1 if min_length is None else max(min_length, 1)
-    return f"({pattern.strip(')(')})" + _build_quantifier(min_length, max_length)
+    if pattern.startswith("(") and pattern.endswith(")"):
+        pattern = pattern[1:-1]
+    return f"({pattern})" + _build_quantifier(min_length, max_length)
 
 
 def _build_quantifier(minimum: int | None, maximum: int | None) -> str:

schemathesis/specs/openapi/serialization.py

@@ -3,6 +3,9 @@ from __future__ import annotations
 import json
 from typing import Any, Callable, Dict, Generator, List
 
+from schemathesis.schemas import APIOperation
+from schemathesis.specs.openapi.constants import LOCATION_TO_CONTAINER
+
 from ...utils import compose
 
 Generated = Dict[str, Any]
@@ -11,6 +14,15 @@ DefinitionList = List[Definition]
 MapFunction = Callable[[Generated], Generated]
 
 
+def get_serializers_for_operation(operation: APIOperation) -> dict[str, Callable]:
+    serializers = {}
+    for location, container in LOCATION_TO_CONTAINER.items():
+        serializer = operation.get_parameter_serializer(location)
+        if serializer is not None:
+            serializers[container] = serializer
+    return serializers
+
+
 def make_serializer(
     func: Callable[[DefinitionList], Generator[Callable | None, None, None]],
 ) -> Callable[[DefinitionList], Callable | None]:

{schemathesis-3.39.10.dist-info → schemathesis-3.39.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: schemathesis
-Version: 3.39.10
+Version: 3.39.12
 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.39.10.dist-info → schemathesis-3.39.12.dist-info}/RECORD

@@ -1,7 +1,7 @@
 schemathesis/__init__.py,sha256=UW2Bq8hDDkcBeAAA7PzpBFXkOOxkmHox-mfQwzHDjL0,1914
 schemathesis/_compat.py,sha256=y4RZd59i2NCnZ91VQhnKeMn_8t3SgvLOk2Xm8nymUHY,1837
 schemathesis/_dependency_versions.py,sha256=pjEkkGAfOQJYNb-9UOo84V8nj_lKHr_TGDVdFwY2UU0,816
-schemathesis/_hypothesis.py,sha256=x1AKO4Cr3LWZQPcRlIvor7ACn5t-mxLJfdHFgpdGHmI,28437
+schemathesis/_hypothesis.py,sha256=CEfWX38CsPy-RzwMGdKuJD9mY_AV8fIq_ZhabGp4tW0,30759
 schemathesis/_lazy_import.py,sha256=aMhWYgbU2JOltyWBb32vnWBb6kykOghucEzI_F70yVE,470
 schemathesis/_override.py,sha256=TAjYB3eJQmlw9K_xiR9ptt9Wj7if4U7UFlUhGjpBAoM,1625
 schemathesis/_patches.py,sha256=Hsbpn4UVeXUQD2Kllrbq01CSWsTYENWa0VJTyhX5C2k,895
@@ -12,7 +12,7 @@ schemathesis/checks.py,sha256=YPUI1N5giGBy1072vd77e6HWelGAKrJUmJLEG4oqfF8,2630
 schemathesis/code_samples.py,sha256=rsdTo6ksyUs3ZMhqx0mmmkPSKUCFa--snIOYsXgZd80,4120
 schemathesis/constants.py,sha256=RHwog2lAz84qG6KCpP1U15A4a9w1xcwbgZ97aY4juQg,2555
 schemathesis/exceptions.py,sha256=5zjPlyVoQNJGbwufplL6ZVV7FEBPBNPHGdlQRJ7xnhE,20449
-schemathesis/failures.py,sha256=mrDu7F-OrQY8pRMNVtIxTjovhfyIkcXYjnSkRw-OMuQ,8016
+schemathesis/failures.py,sha256=OsQM5FDs79usUM4MLA20WIDaoW6SKTR39IyKDjeiwtQ,8197
 schemathesis/filters.py,sha256=f3c_yXIBwIin-9Y0qU2TkcC1NEM_Mw34jGUHQc0BOyw,17026
 schemathesis/graphql.py,sha256=XiuKcfoOB92iLFC8zpz2msLkM0_V0TLdxPNBqrrGZ8w,216
 schemathesis/hooks.py,sha256=p5AXgjVGtka0jn9MOeyBaRUtNbqZTs4iaJqytYTacHc,14856
@@ -28,16 +28,16 @@ schemathesis/targets.py,sha256=XIGRghvEzbmEJjse9aZgNEj67L3jAbiazm2rxURWgDE,2351
 schemathesis/throttling.py,sha256=aisUc4MJDGIOGUAs9L2DlWWpdd4KyAFuNVKhYoaUC9M,1719
 schemathesis/types.py,sha256=Tem2Q_zyMCd0Clp5iGKv6Fu13wdcbxVE8tCVH9WWt7A,1065
 schemathesis/utils.py,sha256=LwqxqoAKmRiAdj-qUbNmgQgsamc49V5lc5TnOIDuuMA,4904
-schemathesis/cli/__init__.py,sha256=IxJnRTCp0bl1B044jjD9GFJ2pisckw3-PBnNHcABBy4,75795
+schemathesis/cli/__init__.py,sha256=jiDVw31fF8oNl0TyAWJpDo-166PkCqNV4t1rUcy_4oo,76352
 schemathesis/cli/__main__.py,sha256=MWaenjaUTZIfNPFzKmnkTiawUri7DVldtg3mirLwzU8,92
-schemathesis/cli/callbacks.py,sha256=-VA_I_mVma9WxFNtUR8d2KNICKJD5ScayfSdKKPEP5Y,16321
+schemathesis/cli/callbacks.py,sha256=UMCYPfoHXgxtT-uui0zlfeNoOLzteJu90q9ID3qt1m4,16540
 schemathesis/cli/cassettes.py,sha256=zji-B-uuwyr0Z0BzQX-DLMV6lWb58JtLExcUE1v3m4Y,20153
 schemathesis/cli/constants.py,sha256=wk-0GsoJIel8wFFerQ6Kf_6eAYUtIWkwMFwyAqv3yj4,1635
 schemathesis/cli/context.py,sha256=j_lvYQiPa6Q7P4P_IGCM9V2y2gJSpDbpxIIzR5oFB2I,2567
 schemathesis/cli/debug.py,sha256=_YA-bX1ujHl4bqQDEum7M-I2XHBTEGbvgkhvcvKhmgU,658
 schemathesis/cli/handlers.py,sha256=EXSAFe5TQlHANz1AVlSttfsoDT2oeaeFbqq1N7e2udw,467
 schemathesis/cli/junitxml.py,sha256=_psBdqGwH4OKySSWeva41mbgGLav86UnWhQyOt99gnU,5331
-schemathesis/cli/options.py,sha256=yL7nrzKkbGCc4nQya9wpTW48XGz_OT9hOFrzPxRrDe4,2853
+schemathesis/cli/options.py,sha256=jPqJxkuAb91wtB_aOUFkGDdGtJ3UDwT2Nn3vvL-odsE,3062
 schemathesis/cli/reporting.py,sha256=KC3sxSc1u4aFQ-0Q8CQ3G4HTEl7QxlubGnJgNKmVJdQ,3627
 schemathesis/cli/sanitization.py,sha256=Onw_NWZSom6XTVNJ5NHnC0PAhrYAcGzIXJbsBCzLkn4,1005
 schemathesis/cli/output/__init__.py,sha256=AXaUzQ1nhQ-vXhW4-X-91vE2VQtEcCOrGtQXXNN55iQ,29
@@ -58,12 +58,12 @@ schemathesis/extra/pytest_plugin.py,sha256=3FF7pcqK26J__FGq6uOZdaD-1tZ-khQEwpdwb
 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=29Zys_tD6kfngaC4zHeC6TOBZQcmo7CWm7KDSYsHStQ,1581
+schemathesis/generation/__init__.py,sha256=PClFLK3bu-8Gsy71rgdD0ULMqySrzX-Um8Tan77x_5A,1628
 schemathesis/generation/_hypothesis.py,sha256=74fzLPHugZgMQXerWYFAMqCAjtAXz5E4gek7Gnkhli4,1756
 schemathesis/generation/_methods.py,sha256=r8oVlJ71_gXcnEhU-byw2E0R2RswQQFm8U7yGErSqbw,1204
 schemathesis/generation/coverage.py,sha256=1CilQSe2DIdMdeWA6RL22so2bZULPRwc0CQBRxcLRFs,39370
 schemathesis/internal/__init__.py,sha256=93HcdG3LF0BbQKbCteOsFMa1w6nXl8yTmx87QLNJOik,161
-schemathesis/internal/checks.py,sha256=YBhldvs-oQTrtvTlz3cjaO9Ri2oQeyobFcquO4Y0UJ8,2720
+schemathesis/internal/checks.py,sha256=ZPvsPJ7gWwK0IpzBFgOMaq4L2e0yfeC8qxPrnpauVFA,2741
 schemathesis/internal/copy.py,sha256=DcL56z-d69kKR_5u8mlHvjSL1UTyUKNMAwexrwHFY1s,1031
 schemathesis/internal/datetime.py,sha256=zPLBL0XXLNfP-KYel3H2m8pnsxjsA_4d-zTOhJg2EPQ,136
 schemathesis/internal/deprecation.py,sha256=XnzwSegbbdQyoTF1OGW_s9pdjIfN_Uzzdb2rfah1w2o,1261
@@ -80,7 +80,7 @@ schemathesis/runner/probes.py,sha256=no5AfO3kse25qvHevjeUfB0Q3C860V2AYzschUW3QMQ
 schemathesis/runner/serialization.py,sha256=vZi1wd9HX9Swp9VJ_hZFeDgy3Y726URpHra-TbPvQhk,20762
 schemathesis/runner/impl/__init__.py,sha256=1E2iME8uthYPBh9MjwVBCTFV-P3fi7AdphCCoBBspjs,199
 schemathesis/runner/impl/context.py,sha256=KY06FXVOFQ6DBaa_FomSBXL81ULs3D21IW1u3yLqs1E,2434
-schemathesis/runner/impl/core.py,sha256=vNWUu5F36brmhsv0P9UYavXLklQo5O2A6byQmS75enY,49289
+schemathesis/runner/impl/core.py,sha256=pB_0zs_MfzAcbrVvRU85mONAn8QXVqFfM_y7yV8a2l0,49962
 schemathesis/runner/impl/solo.py,sha256=y5QSxgK8nBCEjZVD5BpFvYUXmB6tEjk6TwxAo__NejA,2911
 schemathesis/runner/impl/threadpool.py,sha256=yNR5LYE8f3N_4t42OwSgy0_qdGgBPM7d11F9c9oEAAs,15075
 schemathesis/service/__init__.py,sha256=cDVTCFD1G-vvhxZkJUwiToTAEQ-0ByIoqwXvJBCf_V8,472
@@ -107,21 +107,21 @@ schemathesis/specs/graphql/validation.py,sha256=uINIOt-2E7ZuQV2CxKzwez-7L9tDtqzM
 schemathesis/specs/openapi/__init__.py,sha256=HDcx3bqpa6qWPpyMrxAbM3uTo0Lqpg-BUNZhDJSJKnw,279
 schemathesis/specs/openapi/_cache.py,sha256=PAiAu4X_a2PQgD2lG5H3iisXdyg4SaHpU46bRZvfNkM,4320
 schemathesis/specs/openapi/_hypothesis.py,sha256=nU8UDn1PzGCre4IVmwIuO9-CZv1KJe1fYY0d2BojhSo,22981
-schemathesis/specs/openapi/checks.py,sha256=NzUoZ0gZMjyC12KfV7J-5ww8IMaaaNiKum4y7bmA_EA,26816
+schemathesis/specs/openapi/checks.py,sha256=cuHTZsoHV2fdUz23_F99-mLelT1xtvaiS9EcG7R-hZs,26897
 schemathesis/specs/openapi/constants.py,sha256=JqM_FHOenqS_MuUE9sxVQ8Hnw0DNM8cnKDwCwPLhID4,783
 schemathesis/specs/openapi/converter.py,sha256=Yxw9lS_JKEyi-oJuACT07fm04bqQDlAu-iHwzkeDvE4,3546
 schemathesis/specs/openapi/definitions.py,sha256=WTkWwCgTc3OMxfKsqh6YDoGfZMTThSYrHGp8h0vLAK0,93935
-schemathesis/specs/openapi/examples.py,sha256=hdeq7et8AexYGY2iU6SfMZWJ7G0PbOfapUtc4upNs_4,20483
+schemathesis/specs/openapi/examples.py,sha256=yBK0hjq5ROjk7BCLe7BO2dr7raijeZ6_KlZEol-cU-E,20401
 schemathesis/specs/openapi/formats.py,sha256=3KtEC-8nQRwMErS-WpMadXsr8R0O-NzYwFisZqMuc-8,2761
 schemathesis/specs/openapi/links.py,sha256=C4Uir2P_EcpqME8ee_a1vdUM8Tm3ZcKNn2YsGjZiMUQ,17935
 schemathesis/specs/openapi/loaders.py,sha256=jlTYLoG5sVRh8xycIF2M2VDCZ44M80Sct07a_ycg1Po,25698
 schemathesis/specs/openapi/media_types.py,sha256=dNTxpRQbY3SubdVjh4Cjb38R6Bc9MF9BsRQwPD87x0g,1017
 schemathesis/specs/openapi/parameters.py,sha256=X_3PKqUScIiN_vbSFEauPYyxASyFv-_9lZ_9QEZRLqo,14655
-schemathesis/specs/openapi/patterns.py,sha256=OxZp31cBEHv8fwoeYJ9JcdWNHFMIGzRISNN3dCBc9Dg,11260
+schemathesis/specs/openapi/patterns.py,sha256=L99UtslPvwObCVf5ndq3vL2YjQ7H1nMb-ZNMcyz_Qvk,12677
 schemathesis/specs/openapi/references.py,sha256=euxM02kQGMHh4Ss1jWjOY_gyw_HazafKITIsvOEiAvI,9831
 schemathesis/specs/openapi/schemas.py,sha256=JA9SiBnwYg75kYnd4_0CWOuQv_XTfYwuDeGmFe4RtVo,53724
 schemathesis/specs/openapi/security.py,sha256=Z-6pk2Ga1PTUtBe298KunjVHsNh5A-teegeso7zcPIE,7138
-schemathesis/specs/openapi/serialization.py,sha256=5qGdFHZ3n80UlbSXrO_bkr4Al_7ci_Z3aSUjZczNDQY,11384
+schemathesis/specs/openapi/serialization.py,sha256=rcZfqQbWer_RELedu4Sh5h_RhKYPWTfUjnmLwpP2R_A,11842
 schemathesis/specs/openapi/utils.py,sha256=ER4vJkdFVDIE7aKyxyYatuuHVRNutytezgE52pqZNE8,900
 schemathesis/specs/openapi/validation.py,sha256=Q9ThZlwU-mSz7ExDnIivnZGi1ivC5hlX2mIMRAM79kc,999
 schemathesis/specs/openapi/expressions/__init__.py,sha256=hFpJrIWbPi55GcIVjNFRDDUL8xmDu3mdbdldoHBoFJ0,1729
@@ -153,8 +153,8 @@ schemathesis/transports/auth.py,sha256=urSTO9zgFO1qU69xvnKHPFQV0SlJL3d7_Ojl0tLnZ
 schemathesis/transports/content_types.py,sha256=MiKOm-Hy5i75hrROPdpiBZPOTDzOwlCdnthJD12AJzI,2187
 schemathesis/transports/headers.py,sha256=hr_AIDOfUxsJxpHfemIZ_uNG3_vzS_ZeMEKmZjbYiBE,990
 schemathesis/transports/responses.py,sha256=OFD4ZLqwEFpo7F9vaP_SVgjhxAqatxIj38FS4XVq8Qs,1680
-schemathesis-3.39.10.dist-info/METADATA,sha256=3nOKrS8YGysaLXjvt4uIeysV4bbnLxm1WRoG_DD8W8s,11977
-schemathesis-3.39.10.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-schemathesis-3.39.10.dist-info/entry_points.txt,sha256=VHyLcOG7co0nOeuk8WjgpRETk5P1E2iCLrn26Zkn5uk,158
-schemathesis-3.39.10.dist-info/licenses/LICENSE,sha256=PsPYgrDhZ7g9uwihJXNG-XVb55wj2uYhkl2DD8oAzY0,1103
-schemathesis-3.39.10.dist-info/RECORD,,
+schemathesis-3.39.12.dist-info/METADATA,sha256=B2ychHNPR-8UTeOqBUcqdtLzYPdZEO61YaYadjp9B2A,11977
+schemathesis-3.39.12.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+schemathesis-3.39.12.dist-info/entry_points.txt,sha256=VHyLcOG7co0nOeuk8WjgpRETk5P1E2iCLrn26Zkn5uk,158
+schemathesis-3.39.12.dist-info/licenses/LICENSE,sha256=PsPYgrDhZ7g9uwihJXNG-XVb55wj2uYhkl2DD8oAzY0,1103
+schemathesis-3.39.12.dist-info/RECORD,,