schemathesis 4.3.7__py3-none-any.whl → 4.3.9__py3-none-any.whl

schemathesis/core/jsonschema/bundler.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any
 
 from schemathesis.core.errors import InfiniteRecursiveReference
@@ -24,6 +25,14 @@ class BundleError(Exception):
         return f"Cannot bundle `{self.reference}`: expected JSON Schema (object or boolean), got {to_json_type_name(self.value)}"
 
 
+@dataclass
+class Bundle:
+    schema: JsonSchema
+    name_to_uri: dict[str, str]
+
+    __slots__ = ("schema", "name_to_uri")
+
+
 class Bundler:
     """Bundler tracks schema ids stored in a bundle."""
 
@@ -34,16 +43,16 @@ class Bundler:
     def __init__(self) -> None:
         self.counter = 0
 
-    def bundle(self, schema: JsonSchema, resolver: RefResolver, *, inline_recursive: bool) -> JsonSchema:
+    def bundle(self, schema: JsonSchema, resolver: RefResolver, *, inline_recursive: bool) -> Bundle:
         """Bundle a JSON Schema by embedding all references."""
         # Inlining recursive reference is required (for now) for data generation, but is unsound for data validation
         if not isinstance(schema, dict):
-            return schema
+            return Bundle(schema=schema, name_to_uri={})
 
         # Track visited URIs and their local definition names
         inlining_for_recursion: set[str] = set()
         visited: set[str] = set()
-        uri_to_def_name: dict[str, str] = {}
+        uri_to_name: dict[str, str] = {}
         defs = {}
 
         has_recursive_references = False
@@ -52,11 +61,11 @@ class Bundler:
 
         def get_def_name(uri: str) -> str:
             """Generate or retrieve the local definition name for a URI."""
-            name = uri_to_def_name.get(uri)
+            name = uri_to_name.get(uri)
             if name is None:
                 self.counter += 1
                 name = f"schema{self.counter}"
-                uri_to_def_name[uri] = name
+                uri_to_name[uri] = name
             return name
 
         def bundle_recursive(current: JsonSchema | list[JsonSchema]) -> JsonSchema | list[JsonSchema]:
@@ -162,13 +171,13 @@ class Bundler:
             for value in defs.values():
                 if isinstance(value, dict):
                     result.update(value)
-            return result
+            return Bundle(schema=result, name_to_uri={})
 
         if defs:
             bundled[BUNDLE_STORAGE_KEY] = defs
-        return bundled
+        return Bundle(schema=bundled, name_to_uri={v: k for k, v in uri_to_name.items()})
 
 
-def bundle(schema: JsonSchema, resolver: RefResolver, *, inline_recursive: bool) -> JsonSchema:
+def bundle(schema: JsonSchema, resolver: RefResolver, *, inline_recursive: bool) -> Bundle:
     """Bundle a JSON Schema by embedding all references."""
     return Bundler().bundle(schema, resolver, inline_recursive=inline_recursive)

schemathesis/generation/coverage.py

@@ -7,6 +7,8 @@ from dataclasses import dataclass
 from functools import lru_cache, partial
 from itertools import combinations
 
+from schemathesis.core.jsonschema.bundler import BUNDLE_STORAGE_KEY
+
 try:
     from json.encoder import _make_iterencode  # type: ignore[attr-defined]
 except ImportError:
@@ -346,6 +348,19 @@ class CoverageContext:
         if isinstance(schema, dict) and "examples" in schema:
             # Examples may contain binary data which will fail the canonicalisation process in `hypothesis-jsonschema`
             schema = {key: value for key, value in schema.items() if key != "examples"}
+        # Prevent some hard to satisfy schemas
+        if isinstance(schema, dict) and schema.get("additionalProperties") is False and "required" in schema:
+            # Set required properties to any value to simplify generation
+            schema = dict(schema)
+            properties = schema.setdefault("properties", {})
+            for key in schema["required"]:
+                properties.setdefault(key, {})
+
+        # Add bundled schemas if any
+        if isinstance(schema, dict) and BUNDLE_STORAGE_KEY in self.root_schema:
+            schema = dict(schema)
+            schema[BUNDLE_STORAGE_KEY] = self.root_schema[BUNDLE_STORAGE_KEY]
+
         return self.generate_from(from_schema(schema, custom_formats=self.custom_formats))
 
 

schemathesis/generation/hypothesis/builder.py

@@ -529,7 +529,6 @@ def _iter_coverage_cases(
 
     instant = Instant()
     responses = list(operation.responses.iter_examples())
-    # NOTE: The HEAD method is excluded
     custom_formats = _build_custom_formats(generation_config)
 
     seen_negative = coverage.HashSet()

schemathesis/specs/openapi/adapter/parameters.py

@@ -38,11 +38,13 @@ FORM_MEDIA_TYPES = frozenset(["multipart/form-data", "application/x-www-form-url
 class OpenApiComponent(ABC):
     definition: Mapping[str, Any]
     is_required: bool
+    name_to_uri: dict[str, str]
     adapter: SpecificationAdapter
 
     __slots__ = (
         "definition",
         "is_required",
+        "name_to_uri",
         "adapter",
         "_optimized_schema",
         "_unoptimized_schema",
@@ -142,9 +144,11 @@ class OpenApiParameter(OpenApiComponent):
     """OpenAPI operation parameter."""
 
     @classmethod
-    def from_definition(cls, *, definition: Mapping[str, Any], adapter: SpecificationAdapter) -> OpenApiParameter:
+    def from_definition(
+        cls, *, definition: Mapping[str, Any], name_to_uri: dict[str, str], adapter: SpecificationAdapter
+    ) -> OpenApiParameter:
         is_required = definition.get("required", False)
-        return cls(definition=definition, is_required=is_required, adapter=adapter)
+        return cls(definition=definition, is_required=is_required, name_to_uri=name_to_uri, adapter=adapter)
 
     @property
     def name(self) -> str:
@@ -174,12 +178,14 @@ class OpenApiBody(OpenApiComponent):
 
     media_type: str
     resource_name: str | None
+    name_to_uri: dict[str, str]
 
     __slots__ = (
         "definition",
         "is_required",
         "media_type",
         "resource_name",
+        "name_to_uri",
         "adapter",
         "_optimized_schema",
         "_unoptimized_schema",
@@ -195,6 +201,7 @@ class OpenApiBody(OpenApiComponent):
         is_required: bool,
         media_type: str,
         resource_name: str | None,
+        name_to_uri: dict[str, str],
         adapter: SpecificationAdapter,
     ) -> OpenApiBody:
         return cls(
@@ -202,6 +209,7 @@ class OpenApiBody(OpenApiComponent):
             is_required=is_required,
             media_type=media_type,
             resource_name=resource_name,
+            name_to_uri=name_to_uri,
             adapter=adapter,
         )
 
@@ -211,6 +219,7 @@ class OpenApiBody(OpenApiComponent):
         *,
         definition: Mapping[str, Any],
         media_type: str,
+        name_to_uri: dict[str, str],
         adapter: SpecificationAdapter,
     ) -> OpenApiBody:
         return cls(
@@ -218,6 +227,7 @@ class OpenApiBody(OpenApiComponent):
             is_required=True,
             media_type=media_type,
             resource_name=None,
+            name_to_uri=name_to_uri,
             adapter=adapter,
         )
 
@@ -273,19 +283,24 @@ def extract_parameter_schema_v3(parameter: Mapping[str, Any]) -> JsonSchema:
     return media_type_object.get("schema", {})
 
 
-def _bundle_parameter(parameter: Mapping, resolver: RefResolver, bundler: Bundler) -> dict:
+def _bundle_parameter(
+    parameter: Mapping, resolver: RefResolver, bundler: Bundler
+) -> tuple[dict[str, Any], dict[str, str]]:
     """Bundle a parameter definition to make it self-contained."""
     _, definition = maybe_resolve(parameter, resolver, "")
     schema = definition.get("schema")
+    name_to_uri = {}
     if schema is not None:
         definition = {k: v for k, v in definition.items() if k != "schema"}
         try:
-            definition["schema"] = bundler.bundle(schema, resolver, inline_recursive=True)
+            bundled = bundler.bundle(schema, resolver, inline_recursive=True)
+            definition["schema"] = bundled.schema
+            name_to_uri = bundled.name_to_uri
         except BundleError as exc:
             location = parameter.get("in", "")
             name = parameter.get("name", "<UNKNOWN>")
             raise InvalidSchema.from_bundle_error(exc, location, name) from exc
-    return cast(dict, definition)
+    return cast(dict, definition), name_to_uri
 
 
 OPENAPI_20_DEFAULT_BODY_MEDIA_TYPE = "application/json"
@@ -308,15 +323,17 @@ def iter_parameters_v2(
     form_data_media_types = media_types or (OPENAPI_20_DEFAULT_FORM_MEDIA_TYPE,)
 
     form_parameters = []
+    form_name_to_uri = {}
     bundler = Bundler()
     for parameter in chain(definition.get("parameters", []), shared_parameters):
-        parameter = _bundle_parameter(parameter, resolver, bundler)
+        parameter, name_to_uri = _bundle_parameter(parameter, resolver, bundler)
         if parameter["in"] in HEADER_LOCATIONS:
             check_header_name(parameter["name"])
 
         if parameter["in"] == "formData":
             # We need to gather form parameters first before creating a composite parameter for them
             form_parameters.append(parameter)
+            form_name_to_uri.update(name_to_uri)
         elif parameter["in"] == ParameterLocation.BODY:
             # Take the original definition & extract the resource_name from there
             resource_name = None
@@ -330,17 +347,20 @@ def iter_parameters_v2(
                     definition=parameter,
                     is_required=parameter.get("required", False),
                     media_type=media_type,
+                    name_to_uri=name_to_uri,
                     resource_name=resource_name,
                     adapter=adapter,
                 )
         else:
-            yield OpenApiParameter.from_definition(definition=parameter, adapter=adapter)
+            yield OpenApiParameter.from_definition(definition=parameter, name_to_uri=name_to_uri, adapter=adapter)
 
     if form_parameters:
         form_data = form_data_to_json_schema(form_parameters)
         for media_type in form_data_media_types:
             # Individual `formData` parameters are joined into a single "composite" one.
-            yield OpenApiBody.from_form_parameters(definition=form_data, media_type=media_type, adapter=adapter)
+            yield OpenApiBody.from_form_parameters(
+                definition=form_data, media_type=media_type, name_to_uri=form_name_to_uri, adapter=adapter
+            )
 
 
 def iter_parameters_v3(
@@ -356,11 +376,11 @@ def iter_parameters_v3(
 
     bundler = Bundler()
     for parameter in chain(definition.get("parameters", []), shared_parameters):
-        parameter = _bundle_parameter(parameter, resolver, bundler)
+        parameter, name_to_uri = _bundle_parameter(parameter, resolver, bundler)
         if parameter["in"] in HEADER_LOCATIONS:
             check_header_name(parameter["name"])
 
-        yield OpenApiParameter.from_definition(definition=parameter, adapter=adapter)
+        yield OpenApiParameter.from_definition(definition=parameter, name_to_uri=name_to_uri, adapter=adapter)
 
     request_body_or_ref = operation.get("requestBody")
     if request_body_or_ref is not None:
@@ -372,6 +392,7 @@ def iter_parameters_v3(
         for media_type, content in request_body["content"].items():
             resource_name = None
             schema = content.get("schema")
+            name_to_uri = {}
             if isinstance(schema, dict):
                 content = dict(content)
                 if "$ref" in schema:
@@ -379,7 +400,8 @@ def iter_parameters_v3(
                 try:
                     to_bundle = cast(dict[str, Any], schema)
                     bundled = bundler.bundle(to_bundle, resolver, inline_recursive=True)
-                    content["schema"] = bundled
+                    content["schema"] = bundled.schema
+                    name_to_uri = bundled.name_to_uri
                 except BundleError as exc:
                     raise InvalidSchema.from_bundle_error(exc, "body") from exc
             yield OpenApiBody.from_definition(
@@ -387,6 +409,7 @@ def iter_parameters_v3(
                 is_required=required,
                 media_type=media_type,
                 resource_name=resource_name,
+                name_to_uri=name_to_uri,
                 adapter=adapter,
             )
 
@@ -400,6 +423,7 @@ def build_path_parameter_v2(kwargs: Mapping[str, Any]) -> OpenApiParameter:
 
     return OpenApiParameter.from_definition(
         definition={"in": ParameterLocation.PATH.value, "required": True, "type": "string", "minLength": 1, **kwargs},
+        name_to_uri={},
         adapter=v2,
     )
 
@@ -414,6 +438,7 @@ def build_path_parameter_v3_0(kwargs: Mapping[str, Any]) -> OpenApiParameter:
             "schema": {"type": "string", "minLength": 1},
             **kwargs,
         },
+        name_to_uri={},
         adapter=v3_0,
     )
 
@@ -428,6 +453,7 @@ def build_path_parameter_v3_1(kwargs: Mapping[str, Any]) -> OpenApiParameter:
             "schema": {"type": "string", "minLength": 1},
             **kwargs,
         },
+        name_to_uri={},
         adapter=v3_1,
     )
 

schemathesis/specs/openapi/adapter/responses.py

@@ -226,7 +226,7 @@ def _prepare_schema(schema: JsonSchema, resolver: RefResolver, scope: str, nulla
 def _bundle_in_scope(schema: JsonSchema, resolver: RefResolver, scope: str) -> JsonSchema:
     resolver.push_scope(scope)
     try:
-        return bundle(schema, resolver, inline_recursive=False)
+        return bundle(schema, resolver, inline_recursive=False).schema
     except RefResolutionError as exc:
         raise InvalidSchema.from_reference_resolution_error(exc, None, None) from None
     finally:

schemathesis/specs/openapi/checks.py

@@ -14,7 +14,7 @@ from schemathesis.core.failures import Failure
 from schemathesis.core.parameters import ParameterLocation
 from schemathesis.core.transport import Response
 from schemathesis.generation.case import Case
-from schemathesis.generation.meta import CoveragePhaseData
+from schemathesis.generation.meta import CoveragePhaseData, TestPhase
 from schemathesis.openapi.checks import (
     AcceptedNegativeData,
     EnsureResourceAvailability,
@@ -227,9 +227,27 @@ def negative_data_rejection(ctx: CheckContext, response: Response, case: Case) -
         and response.status_code not in allowed_statuses
         and not has_only_additional_properties_in_non_body_parameters(case)
     ):
+        extra_info = ""
+        phase = case.meta.phase
+        if phase and phase.name == TestPhase.COVERAGE and isinstance(phase.data, CoveragePhaseData):
+            parts: list[str] = []
+            if "Missing" in phase.data.description:
+                extra_info = f"\nInvalid component: {phase.data.description}"
+            else:
+                if phase.data.parameter:
+                    parts.append(f"parameter `{phase.data.parameter}`")
+                location = phase.data.parameter_location
+                if location:
+                    parts.append(f"in {location.name.lower()}")
+                description = phase.data.description.lower()
+                if parts:
+                    parts.append(f"({description})")
+                else:
+                    parts.append(f"{description}")
+                extra_info = "\nInvalid component: " + " ".join(parts)
         raise AcceptedNegativeData(
             operation=case.operation.label,
-            message=f"Invalid data should have been rejected\nExpected: {', '.join(config.expected_statuses)}",
+            message=f"Invalid data should have been rejected\nExpected: {', '.join(config.expected_statuses)}{extra_info}",
             status_code=response.status_code,
             expected_statuses=config.expected_statuses,
         )

schemathesis/specs/openapi/schemas.py

@@ -406,7 +406,9 @@ class BaseOpenAPISchema(BaseSchema):
                     and operation.get_parameter(name=param_name, location=param_location) is not None
                 ):
                     continue
-                operation.add_parameter(OpenApiParameter.from_definition(definition=param, adapter=self.adapter))
+                operation.add_parameter(
+                    OpenApiParameter.from_definition(definition=param, name_to_uri={}, adapter=self.adapter)
+                )
         self.dispatch_hook("before_init_operation", HookContext(operation=operation), operation)
         return operation
 

schemathesis/specs/openapi/stateful/dependencies/inputs.py

@@ -1,12 +1,13 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Iterator
+from typing import TYPE_CHECKING, Any, Iterator
 
 from schemathesis.core import media_types
 from schemathesis.core.errors import MalformedMediaType
 from schemathesis.core.jsonschema.bundler import BUNDLE_STORAGE_KEY
 from schemathesis.core.jsonschema.types import get_type
 from schemathesis.core.parameters import ParameterLocation
+from schemathesis.specs.openapi.adapter.parameters import resource_name_from_ref
 from schemathesis.specs.openapi.stateful.dependencies import naming
 from schemathesis.specs.openapi.stateful.dependencies.models import (
     CanonicalizationCache,
@@ -179,6 +180,14 @@ GENERIC_FIELD_NAMES = frozenset(
 )
 
 
+def _maybe_resolve_bundled(root: dict[str, Any], schema: dict[str, Any]) -> dict[str, Any]:
+    # Right now, the body schema comes bundled to dependency analysis
+    if BUNDLE_STORAGE_KEY in root and "$ref" in schema:
+        key = schema["$ref"].split("/")[-1]
+        return root[BUNDLE_STORAGE_KEY][key]
+    return schema
+
+
 def _resolve_body_dependencies(
     *,
     body: OpenApiBody,
@@ -190,12 +199,30 @@ def _resolve_body_dependencies(
     if not isinstance(schema, dict):
         return
 
-    # Right now, the body schema comes bundled to dependency analysis
-    if BUNDLE_STORAGE_KEY in schema and "$ref" in schema:
-        schema_key = schema["$ref"].split("/")[-1]
-        resolved = schema[BUNDLE_STORAGE_KEY][schema_key]
-    else:
-        resolved = schema
+    resolved = _maybe_resolve_bundled(schema, schema)
+
+    # For `items`, we'll inject an array with extracted resource
+    items = resolved.get("items", {})
+    if items is not None:
+        resource_name = naming.from_path(operation.path)
+
+        if "$ref" in items:
+            schema_key = items["$ref"].split("/")[-1]
+            original_ref = body.name_to_uri[schema_key]
+            resource_name = resource_name_from_ref(original_ref)
+            resource = resources.get(resource_name)
+            if resource is None:
+                resource = ResourceDefinition.inferred_from_parameter(name=resource_name, parameter_name=None)
+                resources[resource_name] = resource
+                field = None
+            else:
+                field = None
+            yield InputSlot(
+                resource=resource,
+                resource_field=field,
+                parameter_name=0,
+                parameter_location=ParameterLocation.BODY,
+            )
 
     # Inspect each property that could be a part of some other resource
     properties = resolved.get("properties", {})
@@ -272,7 +299,7 @@ def update_input_field_bindings(resource_name: str, operations: OperationMap) ->
     for operation in operations.values():
         for input_slot in operation.inputs:
             # Skip inputs not using this resource
-            if input_slot.resource.name != resource_name:
+            if input_slot.resource.name != resource_name or isinstance(input_slot.parameter_name, int):
                 continue
 
             # Re-match parameter to upgraded resource fields

schemathesis/specs/openapi/stateful/dependencies/models.py

@@ -58,17 +58,24 @@ class DependencyGraph:
                     links: dict[str, LinkDefinition] = {}
                     for input_slot in consumer.inputs:
                         if input_slot.resource is output_slot.resource:
-                            body_pointer = extend_pointer(
-                                output_slot.pointer, input_slot.resource_field, output_slot.cardinality
-                            )
+                            if input_slot.resource_field is not None:
+                                body_pointer = extend_pointer(
+                                    output_slot.pointer, input_slot.resource_field, output_slot.cardinality
+                                )
+                            else:
+                                # No resource field means use the whole resource
+                                body_pointer = output_slot.pointer
                             link_name = f"{consumer.method.capitalize()}{input_slot.resource.name}"
                             parameters = {}
-                            request_body = {}
+                            request_body: dict[str, Any] | list = {}
                             # Data is extracted from response body
                             if input_slot.parameter_location == ParameterLocation.BODY:
-                                request_body = {
-                                    input_slot.parameter_name: f"$response.body#{body_pointer}",
-                                }
+                                if isinstance(input_slot.parameter_name, int):
+                                    request_body = [f"$response.body#{body_pointer}"]
+                                else:
+                                    request_body = {
+                                        input_slot.parameter_name: f"$response.body#{body_pointer}",
+                                    }
                             else:
                                 parameters = {
                                     f"{input_slot.parameter_location.value}.{input_slot.parameter_name}": f"$response.body#{body_pointer}",
@@ -76,7 +83,10 @@ class DependencyGraph:
                             existing = links.get(link_name)
                             if existing is not None:
                                 existing.parameters.update(parameters)
-                                existing.request_body.update(request_body)
+                                if isinstance(existing.request_body, dict) and isinstance(request_body, dict):
+                                    existing.request_body.update(request_body)
+                                else:
+                                    existing.request_body = request_body
                                 continue
                             links[link_name] = LinkDefinition(
                                 operation_ref=f"#/paths/{consumer_path}/{consumer.method}",
@@ -110,7 +120,9 @@ class DependencyGraph:
                     continue
                 resource = self.resources[input.resource.name]
                 if (
-                    input.resource_field not in resource.fields and resource.name not in known_mismatches
+                    input.resource_field not in resource.fields
+                    and resource.name not in known_mismatches
+                    and input.resource_field is not None
                 ):  # pragma: no cover
                     message = (
                         f"Operation '{operation.method.upper()} {operation.path}': "
@@ -120,7 +132,7 @@ class DependencyGraph:
                     matches = difflib.get_close_matches(input.resource_field, resource.fields, n=1, cutoff=0.6)
                     if matches:
                         message += f". Closest field - `{matches[0]}`"
-                    elif resource.fields:
+                    if resource.fields:
                         message += f". Available fields - {', '.join(resource.fields)}"
                     else:
                         message += ". Resource has no fields"
@@ -151,7 +163,7 @@ class LinkDefinition:
     parameters: dict[str, str]
     """Parameter mappings (e.g., {'path.id': '$response.body#/id'})"""
 
-    request_body: dict[str, str]
+    request_body: dict[str, str] | list
     """Request body (e.g., {'path.id': '$response.body#/id'})"""
 
     __slots__ = ("operation_ref", "parameters", "request_body")
@@ -240,10 +252,12 @@ class InputSlot:
 
     # Which resource is needed
     resource: ResourceDefinition
-    # Which field from that resource (e.g., "id")
-    resource_field: str
+    # Which field from that resource (e.g., "id").
+    # None if passing the whole resource
+    resource_field: str | None
     # Where it goes in the request (e.g., "userId")
-    parameter_name: str
+    # Integer means index in an array (only single items are supported)
+    parameter_name: str | int
     parameter_location: ParameterLocation
 
     __slots__ = ("resource", "resource_field", "parameter_name", "parameter_location")
@@ -284,8 +298,9 @@ class ResourceDefinition:
         return cls(name=name, fields=[], types={}, source=DefinitionSource.SCHEMA_WITHOUT_PROPERTIES)
 
     @classmethod
-    def inferred_from_parameter(cls, name: str, parameter_name: str) -> ResourceDefinition:
-        return cls(name=name, fields=[parameter_name], types={}, source=DefinitionSource.PARAMETER_INFERENCE)
+    def inferred_from_parameter(cls, name: str, parameter_name: str | None) -> ResourceDefinition:
+        fields = [parameter_name] if parameter_name is not None else []
+        return cls(name=name, fields=fields, types={}, source=DefinitionSource.PARAMETER_INFERENCE)
 
 
 class DefinitionSource(enum.IntEnum):

schemathesis/specs/openapi/stateful/dependencies/schemas.py

@@ -93,7 +93,7 @@ def canonicalize(schema: dict[str, Any], resolver: RefResolver) -> Mapping[str,
 
     # Canonicalisation in `hypothesis_jsonschema` requires all references to be resovable and non-recursive
     # On the Schemathesis side bundling solves this problem
-    bundled = bundle(schema, resolver, inline_recursive=True)
+    bundled = bundle(schema, resolver, inline_recursive=True).schema
     canonicalized = canonicalish(bundled)
     resolved = resolve_all_refs(canonicalized)
     resolved.pop(BUNDLE_STORAGE_KEY, None)

{schemathesis-4.3.7.dist-info → schemathesis-4.3.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: schemathesis
-Version: 4.3.7
+Version: 4.3.9
 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://github.com/schemathesis/schemathesis/blob/master/CHANGELOG.md

{schemathesis-4.3.7.dist-info → schemathesis-4.3.9.dist-info}/RECORD

@@ -69,7 +69,7 @@ schemathesis/core/transport.py,sha256=LQcamAkFqJ0HuXQzepevAq2MCJW-uq5Nm-HE9yc7HM
 schemathesis/core/validation.py,sha256=b0USkKzkWvdz3jOW1JXYc_TfYshfKZeP7xAUnMqcNoc,2303
 schemathesis/core/version.py,sha256=dOBUWrY3-uA2NQXJp9z7EtZgkR6jYeLg8sMhQCL1mcI,205
 schemathesis/core/jsonschema/__init__.py,sha256=gBZGsXIpK2EFfcp8x0b69dqzWAm2OeZHepKImkkLvoE,320
-schemathesis/core/jsonschema/bundler.py,sha256=rHaNAVgBn0XvAk3t9dHsyym1xK4FyBW7zR1GLejPD0A,8204
+schemathesis/core/jsonschema/bundler.py,sha256=a8cQMJ7EQe3eWvS3haS2ZpxOUwzA4PY4OLI0Uyx045A,8472
 schemathesis/core/jsonschema/keywords.py,sha256=pjseXTfH9OItNs_Qq6ubkhNWQOrxTnwHmrP_jxrHeJU,631
 schemathesis/core/jsonschema/references.py,sha256=c2Q4IKWUbwENNtkbFaqf8r3LLZu6GFE5YLnYQlg5tPg,6069
 schemathesis/core/jsonschema/types.py,sha256=C7f9g8yKFuoxC5_0YNIh8QAyGU0-tj8pzTMfMDjjjVM,1248
@@ -93,13 +93,13 @@ schemathesis/engine/phases/unit/_executor.py,sha256=YDibV3lkC2UMHLvh1FSmnlaQ-SJS
 schemathesis/engine/phases/unit/_pool.py,sha256=iU0hdHDmohPnEv7_S1emcabuzbTf-Cznqwn0pGQ5wNQ,2480
 schemathesis/generation/__init__.py,sha256=tvNO2FLiY8z3fZ_kL_QJhSgzXfnT4UqwSXMHCwfLI0g,645
 schemathesis/generation/case.py,sha256=SLMw6zkzmeiZdaIij8_0tjTF70BrMlRSWREaqWii0uM,12508
-schemathesis/generation/coverage.py,sha256=dZYX0gkHDHDenrubVQ58P3ww2xf91fEqk9s54AIokw4,59699
+schemathesis/generation/coverage.py,sha256=3eU3HaHr_FCodATskfQ1k4_HHR3z_Pf0Gk_IcVGxLyU,60415
 schemathesis/generation/meta.py,sha256=tXhUZBEdpQMn68uMx1SW8Vv59Uf6Wl6yzs-VB9lu_8o,2589
 schemathesis/generation/metrics.py,sha256=cZU5HdeAMcLFEDnTbNE56NuNq4P0N4ew-g1NEz5-kt4,2836
 schemathesis/generation/modes.py,sha256=Q1fhjWr3zxabU5qdtLvKfpMFZJAwlW9pnxgenjeXTyU,481
 schemathesis/generation/overrides.py,sha256=xI2djHsa42fzP32xpxgxO52INixKagf5DjDAWJYswM8,3890
 schemathesis/generation/hypothesis/__init__.py,sha256=68BHULoXQC1WjFfw03ga5lvDGZ-c-J7H_fNEuUzFWRw,4976
-schemathesis/generation/hypothesis/builder.py,sha256=j7R_X9Z_50xjwIl_Z8DVBe6P1r8leVNvQME7mRLXM1A,38520
+schemathesis/generation/hypothesis/builder.py,sha256=wOCjNAScpiN-wJ4EM0QnJ_5o9nczW0WILFNfIR1qeKQ,38480
 schemathesis/generation/hypothesis/examples.py,sha256=6eGaKUEC3elmKsaqfKj1sLvM8EHc-PWT4NRBq4NI0Rs,1409
 schemathesis/generation/hypothesis/given.py,sha256=sTZR1of6XaHAPWtHx2_WLlZ50M8D5Rjux0GmWkWjDq4,2337
 schemathesis/generation/hypothesis/reporting.py,sha256=uDVow6Ya8YFkqQuOqRsjbzsbyP4KKfr3jA7ZaY4FuKY,279
@@ -130,7 +130,7 @@ schemathesis/specs/graphql/schemas.py,sha256=GKJcnTAT1wUzzUr3r6wiTfiAdFLcgFQjYRR
 schemathesis/specs/graphql/validation.py,sha256=-W1Noc1MQmTb4RX-gNXMeU2qkgso4mzVfHxtdLkCPKM,1422
 schemathesis/specs/openapi/__init__.py,sha256=C5HOsfuDJGq_3mv8CRBvRvb0Diy1p0BFdqyEXMS-loE,238
 schemathesis/specs/openapi/_hypothesis.py,sha256=O8vN-koBjzBVZfpD3pmgIt6ecU4ddAPHOxTAORd23Lo,22642
-schemathesis/specs/openapi/checks.py,sha256=YYV6j6idyw2ubY4sLp-avs2OVEkAWeIihjT0xiV1RRA,30669
+schemathesis/specs/openapi/checks.py,sha256=12ks0V2F8-YKPkItgAc0ZrxsHufWWlsgj-jpj-cF40A,31578
 schemathesis/specs/openapi/converter.py,sha256=4a6-8STT5snF7B-t6IsOIGdK5rV16oNqsdvWL7VFf2M,6472
 schemathesis/specs/openapi/definitions.py,sha256=8htclglV3fW6JPBqs59lgM4LnA25Mm9IptXBPb_qUT0,93949
 schemathesis/specs/openapi/examples.py,sha256=moFFfOfzepjlJOrqLc60BrEmJ4oRzwJ3SM03y_nJNMU,24097
@@ -138,14 +138,14 @@ schemathesis/specs/openapi/formats.py,sha256=4tYRdckauHxkJCmOhmdwDq_eOpHPaKloi89
 schemathesis/specs/openapi/media_types.py,sha256=F5M6TKl0s6Z5X8mZpPsWDEdPBvxclKRcUOc41eEwKbo,2472
 schemathesis/specs/openapi/patterns.py,sha256=GqPZEXMRdWENQxanWjBOalIZ2MQUjuxk21kmdiI703E,18027
 schemathesis/specs/openapi/references.py,sha256=AW1laU23BkiRf0EEFM538vyVFLXycGUiucGVV461le0,1927
-schemathesis/specs/openapi/schemas.py,sha256=vwBgw7kznPlQJIufgJ48oRxCzDFkUWKfb4uK7rMZUT4,33704
+schemathesis/specs/openapi/schemas.py,sha256=uTxwggtWi5dWjuKlSDs0DthlNNfcRvSJtrND-PaTkrg,33758
 schemathesis/specs/openapi/serialization.py,sha256=RPNdadne5wdhsGmjSvgKLRF58wpzpRx3wura8PsHM3o,12152
 schemathesis/specs/openapi/utils.py,sha256=XkOJT8qD-6uhq-Tmwxk_xYku1Gy5F9pKL3ldNg_DRZw,522
 schemathesis/specs/openapi/adapter/__init__.py,sha256=YEovBgLjnXd3WGPMJXq0KbSGHezkRlEv4dNRO7_evfk,249
-schemathesis/specs/openapi/adapter/parameters.py,sha256=MYEQUxhtv23e1uhoDq5bDHMUT3Q64bW7aZloJuz13QY,18626
+schemathesis/specs/openapi/adapter/parameters.py,sha256=bVo7sgN5oCH2GVDXlqAMrwN0z5pb8VKf3_FOkSgTGDA,19567
 schemathesis/specs/openapi/adapter/protocol.py,sha256=VDF6COcilHEUnmw76YBVur8bFiTFQHsNvaO9pR_i_KM,2709
 schemathesis/specs/openapi/adapter/references.py,sha256=6M59pJy_U_sLh3Xzgu6-izWXtz3bjXnqJYSD65wRHtk,549
-schemathesis/specs/openapi/adapter/responses.py,sha256=0iC0i6AF3VMVlTiKxBNLFHG_W22-5K731fVMdhUk9Kk,13269
+schemathesis/specs/openapi/adapter/responses.py,sha256=UXcYb048SeS0MhydQY518IgYD0s0Q5YpLsBbdX5-5-s,13276
 schemathesis/specs/openapi/adapter/security.py,sha256=W3cqlbs80NxF9SAavOi7BhtNGzdxHO476lYxiWN0D08,4945
 schemathesis/specs/openapi/adapter/v2.py,sha256=2Rd1cTv7_I5QrBPLVfa2yD80NAErxV3tdeACjtEfXAA,1280
 schemathesis/specs/openapi/adapter/v3_0.py,sha256=8bOE9WUDrvPivGs0w-S1PP2TXgWuaoTzMdg2_WWbi-E,1272
@@ -165,12 +165,12 @@ schemathesis/specs/openapi/stateful/control.py,sha256=QaXLSbwQWtai5lxvvVtQV3BLJ8
 schemathesis/specs/openapi/stateful/inference.py,sha256=B99jSTDVi2yKxU7-raIb91xpacOrr0nZkEZY5Ej3eCY,9783
 schemathesis/specs/openapi/stateful/links.py,sha256=SSA66mU50FFBz7e6sA37CfL-Vt0OY3gont72oFSvZYU,8163
 schemathesis/specs/openapi/stateful/dependencies/__init__.py,sha256=0JM-FrY6Awv6gl-qDHaaK7pXbt_GKutBKPyIaph8apA,7842
-schemathesis/specs/openapi/stateful/dependencies/inputs.py,sha256=1qVVIlzx52qsy55Pht9dYNtn2dewRSiHegfrBO1RD8c,10347
-schemathesis/specs/openapi/stateful/dependencies/models.py,sha256=P1GsX0P8YQboQJDG7DXEksJU279Vt_wYqpHb6uk1Hkg,11280
+schemathesis/specs/openapi/stateful/dependencies/inputs.py,sha256=PSactImp4OqsYMHUl2gB2pgvUlZCCKJRJKeaalclFzU,11511
+schemathesis/specs/openapi/stateful/dependencies/models.py,sha256=Kl482Hwq2M8lYAdqGmf_8Yje3voSj1WLDUIujRUDWDQ,12286
 schemathesis/specs/openapi/stateful/dependencies/naming.py,sha256=HfpkCB1GglX1BAKXer3llvPkQsk8wx0QZhZq7ANcdMM,12214
 schemathesis/specs/openapi/stateful/dependencies/outputs.py,sha256=zvVUfQWNIuhMkKDpz5hsVGkkvkefLt1EswpJAnHajOw,1186
 schemathesis/specs/openapi/stateful/dependencies/resources.py,sha256=p58XoADpMKFAun0Bx_rul-kiUlfA9PXjxHJ97dT2tBE,11202
-schemathesis/specs/openapi/stateful/dependencies/schemas.py,sha256=yMu13RsXIPDeZT1tATTxI1vkpYhjs-XFSFEvx3_Xh_Q,14094
+schemathesis/specs/openapi/stateful/dependencies/schemas.py,sha256=snDmf2SWsvo9Oqk_X8xF8GB0Fbwx429UA6ZL2IokzDY,14101
 schemathesis/specs/openapi/types/__init__.py,sha256=VPsWtLJle__Kodw_QqtQ3OuvBzBcCIKsTOrXy3eA7OU,66
 schemathesis/specs/openapi/types/v3.py,sha256=Vondr9Amk6JKCIM6i6RGcmTUjFfPgOOqzBXqerccLpo,1468
 schemathesis/transport/__init__.py,sha256=6yg_RfV_9L0cpA6qpbH-SL9_3ggtHQji9CZrpIkbA6s,5321
@@ -179,8 +179,8 @@ schemathesis/transport/prepare.py,sha256=erYXRaxpQokIDzaIuvt_csHcw72iHfCyNq8VNEz
 schemathesis/transport/requests.py,sha256=wriRI9fprTplE_qEZLEz1TerX6GwkE3pwr6ZnU2o6vQ,10648
 schemathesis/transport/serialization.py,sha256=GwO6OAVTmL1JyKw7HiZ256tjV4CbrRbhQN0ep1uaZwI,11157
 schemathesis/transport/wsgi.py,sha256=kQtasFre6pjdJWRKwLA_Qb-RyQHCFNpaey9ubzlFWKI,5907
-schemathesis-4.3.7.dist-info/METADATA,sha256=hxCdew3yx_fJyUv0iunB3526jFD0HhlSnKCv9DCXV_o,8540
-schemathesis-4.3.7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-schemathesis-4.3.7.dist-info/entry_points.txt,sha256=hiK3un-xfgPdwj9uj16YVDtTNpO128bmk0U82SMv8ZQ,152
-schemathesis-4.3.7.dist-info/licenses/LICENSE,sha256=2Ve4J8v5jMQAWrT7r1nf3bI8Vflk3rZVQefiF2zpxwg,1121
-schemathesis-4.3.7.dist-info/RECORD,,
+schemathesis-4.3.9.dist-info/METADATA,sha256=xqdweDGbn3i_jr_ZEgDMgh0vU8alhih5bINIKkPW0fU,8540
+schemathesis-4.3.9.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+schemathesis-4.3.9.dist-info/entry_points.txt,sha256=hiK3un-xfgPdwj9uj16YVDtTNpO128bmk0U82SMv8ZQ,152
+schemathesis-4.3.9.dist-info/licenses/LICENSE,sha256=2Ve4J8v5jMQAWrT7r1nf3bI8Vflk3rZVQefiF2zpxwg,1121
+schemathesis-4.3.9.dist-info/RECORD,,