schemathesis 3.38.7__py3-none-any.whl → 3.38.9__py3-none-any.whl

schemathesis/_hypothesis.py

@@ -237,17 +237,17 @@ def _iter_coverage_cases(
     template: dict[str, Any] = {}
     responses = find_in_responses(operation)
     for parameter in operation.iter_parameters():
+        location = parameter.location
+        name = parameter.name
         schema = parameter.as_json_schema(operation, update_quantifiers=False)
         for value in find_matching_in_responses(responses, parameter.name):
             schema.setdefault("examples", []).append(value)
         gen = coverage.cover_schema_iter(
-            coverage.CoverageContext(data_generation_methods=data_generation_methods), schema
+            coverage.CoverageContext(location=location, data_generation_methods=data_generation_methods), schema
         )
         value = next(gen, NOT_SET)
         if isinstance(value, NotSet):
             continue
-        location = parameter.location
-        name = parameter.name
         container = template.setdefault(LOCATION_TO_CONTAINER[location], {})
         if location in ("header", "cookie", "path", "query") and not isinstance(value.value, str):
             container[name] = _stringify_value(value.value, location)
@@ -263,7 +263,7 @@ def _iter_coverage_cases(
             if examples:
                 schema.setdefault("examples", []).extend(examples)
             gen = coverage.cover_schema_iter(
-                coverage.CoverageContext(data_generation_methods=data_generation_methods), schema
+                coverage.CoverageContext(location="body", data_generation_methods=data_generation_methods), schema
             )
             value = next(gen, NOT_SET)
             if isinstance(value, NotSet):
@@ -417,7 +417,7 @@ def _iter_coverage_cases(
             subschema: dict[str, Any], _location: str, _container_name: str
         ) -> Generator[Case, None, None]:
             for more in coverage.cover_schema_iter(
-                coverage.CoverageContext(data_generation_methods=[DataGenerationMethod.negative]),
+                coverage.CoverageContext(location=_location, data_generation_methods=[DataGenerationMethod.negative]),
                 subschema,
             ):
                 yield make_case(
@@ -432,17 +432,26 @@ def _iter_coverage_cases(
         # 1. Generate only required properties
         if required and all_params != required:
             only_required = {k: v for k, v in base_container.items() if k in required}
-            yield make_case(
-                only_required, "Only required properties", location, container_name, None, DataGenerationMethod.positive
-            )
+            if DataGenerationMethod.positive in data_generation_methods:
+                yield make_case(
+                    only_required,
+                    "Only required properties",
+                    location,
+                    container_name,
+                    None,
+                    DataGenerationMethod.positive,
+                )
             if DataGenerationMethod.negative in data_generation_methods:
                 subschema = _combination_schema(only_required, required, parameter_set)
-                yield from _yield_negative(subschema, location, container_name)
+                for case in _yield_negative(subschema, location, container_name):
+                    # Already generated in one of the blocks above
+                    if location != "path" and not case.meta.description.startswith("Missing required property"):
+                        yield case
 
         # 2. Generate combinations with required properties and one optional property
         for opt_param in optional:
             combo = {k: v for k, v in base_container.items() if k in required or k == opt_param}
-            if combo != base_container:
+            if combo != base_container and DataGenerationMethod.positive in data_generation_methods:
                 yield make_case(
                     combo,
                     f"All required properties and optional '{opt_param}'",
@@ -453,10 +462,13 @@ def _iter_coverage_cases(
                 )
                 if DataGenerationMethod.negative in data_generation_methods:
                     subschema = _combination_schema(combo, required, parameter_set)
-                    yield from _yield_negative(subschema, location, container_name)
+                    for case in _yield_negative(subschema, location, container_name):
+                        # Already generated in one of the blocks above
+                        if location != "path" and not case.meta.description.startswith("Missing required property"):
+                            yield case
 
         # 3. Generate one combination for each size from 2 to N-1 of optional parameters
-        if len(optional) > 1:
+        if len(optional) > 1 and DataGenerationMethod.positive in data_generation_methods:
             for size in range(2, len(optional)):
                 for combination in combinations(optional, size):
                     combo = {k: v for k, v in base_container.items() if k in required or k in combination}

schemathesis/cli/__init__.py

@@ -323,6 +323,15 @@ REPORT_TO_SERVICE = ReportToService()
     multiple=True,
     metavar="",
 )
+@grouped_option(
+    "--experimental-missing-required-header-allowed-statuses",
+    "missing_required_header_allowed_statuses",
+    help="Comma-separated list of status codes expected for test cases with a missing required header",
+    type=CsvListChoice(),
+    callback=callbacks.convert_status_codes,
+    metavar="",
+    envvar="SCHEMATHESIS_EXPERIMENTAL_MISSING_REQUIRED_HEADER_ALLOWED_STATUSES",
+)
 @grouped_option(
     "--experimental-positive-data-acceptance-allowed-statuses",
     "positive_data_acceptance_allowed_statuses",
@@ -855,6 +864,7 @@ def run(
     set_cookie: dict[str, str],
     set_path: dict[str, str],
     experiments: list,
+    missing_required_header_allowed_statuses: list[str],
     positive_data_acceptance_allowed_statuses: list[str],
     negative_data_rejection_allowed_statuses: list[str],
     checks: Iterable[str] = DEFAULT_CHECKS_NAMES,
@@ -1172,6 +1182,11 @@ def run(
         selected_checks += (positive_data_acceptance,)
         if positive_data_acceptance_allowed_statuses:
             checks_config.positive_data_acceptance.allowed_statuses = positive_data_acceptance_allowed_statuses
+    if missing_required_header_allowed_statuses:
+        from ..specs.openapi.checks import missing_required_header
+
+        selected_checks += (missing_required_header,)
+        checks_config.missing_required_header.allowed_statuses = missing_required_header_allowed_statuses
     if negative_data_rejection_allowed_statuses:
         checks_config.negative_data_rejection.allowed_statuses = negative_data_rejection_allowed_statuses
 

schemathesis/generation/coverage.py

@@ -21,6 +21,7 @@ from ..internal.copy import fast_deepcopy
 from ..specs.openapi.converter import update_pattern_in_schema
 from ..specs.openapi.formats import STRING_FORMATS, get_default_format_strategies
 from ..specs.openapi.patterns import update_quantifier
+from ..transports.headers import has_invalid_characters, is_latin_1_encodable
 from ._hypothesis import get_single_example
 from ._methods import DataGenerationMethod
 
@@ -103,42 +104,55 @@ def cached_draw(strategy: st.SearchStrategy) -> Any:
 @dataclass
 class CoverageContext:
     data_generation_methods: list[DataGenerationMethod]
-    location_stack: list[str | int]
+    location: str
+    path: list[str | int]
 
-    __slots__ = ("data_generation_methods", "location_stack")
+    __slots__ = ("location", "data_generation_methods", "path")
 
     def __init__(
         self,
+        *,
+        location: str,
         data_generation_methods: list[DataGenerationMethod] | None = None,
-        location_stack: list[str | int] | None = None,
+        path: list[str | int] | None = None,
     ) -> None:
+        self.location = location
         self.data_generation_methods = (
             data_generation_methods if data_generation_methods is not None else DataGenerationMethod.all()
         )
-        self.location_stack = location_stack or []
+        self.path = path or []
 
     @contextmanager
-    def location(self, key: str | int) -> Generator[None, None, None]:
-        self.location_stack.append(key)
+    def at(self, key: str | int) -> Generator[None, None, None]:
+        self.path.append(key)
         try:
             yield
         finally:
-            self.location_stack.pop()
+            self.path.pop()
 
     @property
-    def current_location(self) -> str:
-        return "/" + "/".join(str(key) for key in self.location_stack)
+    def current_path(self) -> str:
+        return "/" + "/".join(str(key) for key in self.path)
 
     def with_positive(self) -> CoverageContext:
         return CoverageContext(
-            data_generation_methods=[DataGenerationMethod.positive], location_stack=self.location_stack
+            location=self.location,
+            data_generation_methods=[DataGenerationMethod.positive],
+            path=self.path,
         )
 
     def with_negative(self) -> CoverageContext:
         return CoverageContext(
-            data_generation_methods=[DataGenerationMethod.negative], location_stack=self.location_stack
+            location=self.location,
+            data_generation_methods=[DataGenerationMethod.negative],
+            path=self.path,
         )
 
+    def is_valid_for_location(self, value: Any) -> bool:
+        if self.location in ("header", "cookie") and isinstance(value, str):
+            return is_latin_1_encodable(value) and not has_invalid_characters("", value)
+        return True
+
     def generate_from(self, strategy: st.SearchStrategy) -> Any:
         return cached_draw(strategy)
 
@@ -322,7 +336,7 @@ def cover_schema_iter(
     if DataGenerationMethod.negative in ctx.data_generation_methods:
         template = None
         for key, value in schema.items():
-            with _ignore_unfixable(), ctx.location(key):
+            with _ignore_unfixable(), ctx.at(key):
                 if key == "enum":
                     yield from _negative_enum(ctx, value, seen)
                 elif key == "const":
@@ -350,21 +364,17 @@ def cover_schema_iter(
                 elif key == "maximum":
                     next = value + 1
                     if next not in seen:
-                        yield NegativeValue(
-                            next, description="Value greater than maximum", location=ctx.current_location
-                        )
+                        yield NegativeValue(next, description="Value greater than maximum", location=ctx.current_path)
                         seen.add(next)
                 elif key == "minimum":
                     next = value - 1
                     if next not in seen:
-                        yield NegativeValue(
-                            next, description="Value smaller than minimum", location=ctx.current_location
-                        )
+                        yield NegativeValue(next, description="Value smaller than minimum", location=ctx.current_path)
                         seen.add(next)
                 elif key == "exclusiveMaximum" or key == "exclusiveMinimum" and value not in seen:
                     verb = "greater" if key == "exclusiveMaximum" else "smaller"
                     limit = "maximum" if key == "exclusiveMaximum" else "minimum"
-                    yield NegativeValue(value, description=f"Value {verb} than {limit}", location=ctx.current_location)
+                    yield NegativeValue(value, description=f"Value {verb} than {limit}", location=ctx.current_path)
                     seen.add(value)
                 elif key == "multipleOf":
                     for value_ in _negative_multiple_of(ctx, schema, value):
@@ -391,7 +401,7 @@ def cover_schema_iter(
                         k = _to_hashable_key(value)
                         if k not in seen:
                             yield NegativeValue(
-                                value, description="String smaller than minLength", location=ctx.current_location
+                                value, description="String smaller than minLength", location=ctx.current_path
                             )
                             seen.add(k)
                 elif key == "maxLength" and value < BUFFER_SIZE:
@@ -413,7 +423,7 @@ def cover_schema_iter(
                         k = _to_hashable_key(value)
                         if k not in seen:
                             yield NegativeValue(
-                                value, description="String larger than maxLength", location=ctx.current_location
+                                value, description="String larger than maxLength", location=ctx.current_path
                             )
                             seen.add(k)
                     except (InvalidArgument, Unsatisfiable):
@@ -428,12 +438,12 @@ def cover_schema_iter(
                     yield NegativeValue(
                         {**template, UNKNOWN_PROPERTY_KEY: UNKNOWN_PROPERTY_VALUE},
                         description="Object with unexpected properties",
-                        location=ctx.current_location,
+                        location=ctx.current_path,
                     )
                 elif key == "allOf":
                     nctx = ctx.with_negative()
                     if len(value) == 1:
-                        with nctx.location(0):
+                        with nctx.at(0):
                             yield from cover_schema_iter(nctx, value[0], seen)
                     else:
                         with _ignore_unfixable():
@@ -443,7 +453,7 @@ def cover_schema_iter(
                     nctx = ctx.with_negative()
                     # NOTE: Other sub-schemas are not filtered out
                     for idx, sub_schema in enumerate(value):
-                        with nctx.location(idx):
+                        with nctx.at(idx):
                             yield from cover_schema_iter(nctx, sub_schema, seen)
 
 
@@ -487,15 +497,17 @@ def _positive_string(ctx: CoverageContext, schema: dict) -> Generator[GeneratedV
     examples = schema.get("examples")
     default = schema.get("default")
     if example or examples or default:
-        if example:
+        if example and ctx.is_valid_for_location(example):
             yield PositiveValue(example, description="Example value")
         if examples:
             for example in examples:
-                yield PositiveValue(example, description="Example value")
+                if ctx.is_valid_for_location(example):
+                    yield PositiveValue(example, description="Example value")
         if (
             default
             and not (example is not None and default == example)
             and not (examples is not None and any(default == ex for ex in examples))
+            and ctx.is_valid_for_location(default)
         ):
             yield PositiveValue(default, description="Default value")
     elif not min_length and not max_length:
@@ -748,14 +760,14 @@ def _negative_enum(
     ctx: CoverageContext, value: list, seen: set[Any | tuple[type, str]]
 ) -> Generator[GeneratedValue, None, None]:
     def is_not_in_value(x: Any) -> bool:
-        if x in value:
+        if x in value or not ctx.is_valid_for_location(x):
             return False
         _hashed = _to_hashable_key(x)
         return _hashed not in seen
 
     strategy = (st.none() | st.booleans() | NUMERIC_STRATEGY | st.text()).filter(is_not_in_value)
     value = ctx.generate_from(strategy)
-    yield NegativeValue(value, description="Invalid enum value", location=ctx.current_location)
+    yield NegativeValue(value, description="Invalid enum value", location=ctx.current_path)
     hashed = _to_hashable_key(value)
     seen.add(hashed)
 
@@ -765,12 +777,12 @@ def _negative_properties(
 ) -> Generator[GeneratedValue, None, None]:
     nctx = ctx.with_negative()
     for key, sub_schema in properties.items():
-        with nctx.location(key):
+        with nctx.at(key):
             for value in cover_schema_iter(nctx, sub_schema):
                 yield NegativeValue(
                     {**template, key: value.value},
                     description=f"Object with invalid '{key}' value: {value.description}",
-                    location=nctx.current_location,
+                    location=nctx.current_path,
                     parameter=key,
                 )
 
@@ -784,12 +796,12 @@ def _negative_pattern_properties(
             key = ctx.generate_from(st.from_regex(pattern))
         except re.error:
             continue
-        with nctx.location(pattern):
+        with nctx.at(pattern):
             for value in cover_schema_iter(nctx, sub_schema):
                 yield NegativeValue(
                     {**template, key: value.value},
                     description=f"Object with invalid pattern key '{key}' ('{pattern}') value: {value.description}",
-                    location=nctx.current_location,
+                    location=nctx.current_path,
                 )
 
 
@@ -800,7 +812,7 @@ def _negative_items(ctx: CoverageContext, schema: dict[str, Any] | bool) -> Gene
         yield NegativeValue(
             [value.value],
             description=f"Array with invalid items: {value.description}",
-            location=nctx.current_location,
+            location=nctx.current_path,
         )
 
 
@@ -817,12 +829,12 @@ def _negative_pattern(
         return
     yield NegativeValue(
         ctx.generate_from(
-            st.text(min_size=min_length or 0, max_size=max_length).filter(
-                partial(_not_matching_pattern, pattern=compiled)
-            )
+            st.text(min_size=min_length or 0, max_size=max_length)
+            .filter(partial(_not_matching_pattern, pattern=compiled))
+            .filter(ctx.is_valid_for_location)
         ),
         description=f"Value not matching the '{pattern}' pattern",
-        location=ctx.current_location,
+        location=ctx.current_path,
     )
 
 
@@ -836,13 +848,13 @@ def _negative_multiple_of(
     yield NegativeValue(
         ctx.generate_from_schema(_with_negated_key(schema, "multipleOf", multiple_of)),
         description=f"Non-multiple of {multiple_of}",
-        location=ctx.current_location,
+        location=ctx.current_path,
     )
 
 
 def _negative_unique_items(ctx: CoverageContext, schema: dict) -> Generator[GeneratedValue, None, None]:
     unique = ctx.generate_from_schema({**schema, "type": "array", "minItems": 1, "maxItems": 1})
-    yield NegativeValue(unique + unique, description="Non-unique items", location=ctx.current_location)
+    yield NegativeValue(unique + unique, description="Non-unique items", location=ctx.current_path)
 
 
 def _negative_required(
@@ -852,7 +864,7 @@ def _negative_required(
         yield NegativeValue(
             {k: v for k, v in template.items() if k != key},
             description=f"Missing required property: {key}",
-            location=ctx.current_location,
+            location=ctx.current_path,
             parameter=key,
         )
 
@@ -878,7 +890,7 @@ def _negative_format(ctx: CoverageContext, schema: dict, format: str) -> Generat
     yield NegativeValue(
         ctx.generate_from(strategy),
         description=f"Value not matching the '{format}' format",
-        location=ctx.current_location,
+        location=ctx.current_path,
     )
 
 
@@ -901,7 +913,7 @@ def _negative_type(ctx: CoverageContext, seen: set, ty: str | list[str]) -> Gene
         hashed = _to_hashable_key(value)
         if hashed in seen:
             continue
-        yield NegativeValue(value, description="Incorrect type", location=ctx.current_location)
+        yield NegativeValue(value, description="Incorrect type", location=ctx.current_path)
         seen.add(hashed)
 
 

schemathesis/internal/checks.py

@@ -29,8 +29,14 @@ class PositiveDataAcceptanceConfig:
     allowed_statuses: list[str] = field(default_factory=lambda: ["2xx", "401", "403", "404"])
 
 
+@dataclass
+class MissingRequiredHeaderConfig:
+    allowed_statuses: list[str] = field(default_factory=lambda: ["406"])
+
+
 @dataclass
 class CheckConfig:
+    missing_required_header: MissingRequiredHeaderConfig = field(default_factory=MissingRequiredHeaderConfig)
     negative_data_rejection: NegativeDataRejectionConfig = field(default_factory=NegativeDataRejectionConfig)
     positive_data_acceptance: PositiveDataAcceptanceConfig = field(default_factory=PositiveDataAcceptanceConfig)
 

schemathesis/models.py

@@ -622,6 +622,7 @@ class Case:
             cookies=fast_deepcopy(self.cookies),
             query=fast_deepcopy(self.query),
             body=fast_deepcopy(self.body),
+            meta=self.meta,
             generation_time=self.generation_time,
             id=self.id,
             _auth=self._auth,

schemathesis/specs/openapi/checks.py

@@ -269,6 +269,20 @@ def positive_data_acceptance(ctx: CheckContext, response: GenericResponse, case:
     return None
 
 
+def missing_required_header(ctx: CheckContext, response: GenericResponse, case: Case) -> bool | None:
+    if (
+        case.meta
+        and case.meta.parameter_location == "header"
+        and case.meta.description
+        and case.meta.description.startswith("Missing ")
+    ):
+        config = ctx.config.missing_required_header
+        allowed_statuses = expand_status_codes(config.allowed_statuses or [])
+        if response.status_code not in allowed_statuses:
+            raise AssertionError(f"Unexpected response status for a missing header: {response.status_code}")
+    return None
+
+
 def has_only_additional_properties_in_non_body_parameters(case: Case) -> bool:
     # Check if the case contains only additional properties in query, headers, or cookies.
     # This function is used to determine if negation is solely in the form of extra properties,

{schemathesis-3.38.7.dist-info → schemathesis-3.38.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: schemathesis
-Version: 3.38.7
+Version: 3.38.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://schemathesis.readthedocs.io/en/stable/changelog.html

{schemathesis-3.38.7.dist-info → schemathesis-3.38.9.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=7hQItl5JqtctCiN7gL4DhWmj8A0Ku6t1_pkxEqkID1g,23463
+schemathesis/_hypothesis.py,sha256=PsmomVk_mXZaqhOZJh5qftYSJ7qJs3wwBTSITiBXvT0,24273
 schemathesis/_lazy_import.py,sha256=aMhWYgbU2JOltyWBb32vnWBb6kykOghucEzI_F70yVE,470
 schemathesis/_override.py,sha256=TAjYB3eJQmlw9K_xiR9ptt9Wj7if4U7UFlUhGjpBAoM,1625
 schemathesis/_patches.py,sha256=Hsbpn4UVeXUQD2Kllrbq01CSWsTYENWa0VJTyhX5C2k,895
@@ -18,7 +18,7 @@ schemathesis/graphql.py,sha256=XiuKcfoOB92iLFC8zpz2msLkM0_V0TLdxPNBqrrGZ8w,216
 schemathesis/hooks.py,sha256=p5AXgjVGtka0jn9MOeyBaRUtNbqZTs4iaJqytYTacHc,14856
 schemathesis/lazy.py,sha256=Ddhkk7Tpc_VcRGYkCtKDmP2gpjxVmEZ3b01ZTNjbm8I,19004
 schemathesis/loaders.py,sha256=MoEhcdOEBJxNRn5X-ZNhWB9jZDHQQNpkNfEdQjf_NDw,4590
-schemathesis/models.py,sha256=Xn1rEF0_g3HNqJaJB9sC8N3gJ9suFPPlgc8ho01VyF0,49769
+schemathesis/models.py,sha256=zE-j-5uyQdIxnWx-rqJyXCbyrWZlrTyiTml109yZeN4,49797
 schemathesis/parameters.py,sha256=izlu4MFYT1RWrC4RBxrV6weeCal-ODbdLQLMb0PYCZY,2327
 schemathesis/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 schemathesis/sanitization.py,sha256=Lycn1VVfula9B6XpzkxTHja7CZ7RHqbUh9kBic0Yi4M,9056
@@ -28,7 +28,7 @@ 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=rAebJYQrORWsl4WR6sLUseJCQQZbDEsaQex52kmn6kI,74536
+schemathesis/cli/__init__.py,sha256=GlM52jH2p8pSoHnSc0mfxNRTGVLslT_9rTLLy3jgbgo,75272
 schemathesis/cli/__main__.py,sha256=MWaenjaUTZIfNPFzKmnkTiawUri7DVldtg3mirLwzU8,92
 schemathesis/cli/callbacks.py,sha256=-VA_I_mVma9WxFNtUR8d2KNICKJD5ScayfSdKKPEP5Y,16321
 schemathesis/cli/cassettes.py,sha256=zji-B-uuwyr0Z0BzQX-DLMV6lWb58JtLExcUE1v3m4Y,20153
@@ -61,9 +61,9 @@ schemathesis/fixups/utf8_bom.py,sha256=lWT9RNmJG8i-l5AXIpaCT3qCPUwRgzXPW3eoOjmZE
 schemathesis/generation/__init__.py,sha256=29Zys_tD6kfngaC4zHeC6TOBZQcmo7CWm7KDSYsHStQ,1581
 schemathesis/generation/_hypothesis.py,sha256=74fzLPHugZgMQXerWYFAMqCAjtAXz5E4gek7Gnkhli4,1756
 schemathesis/generation/_methods.py,sha256=r8oVlJ71_gXcnEhU-byw2E0R2RswQQFm8U7yGErSqbw,1204
-schemathesis/generation/coverage.py,sha256=Y-eKsEDe6INu-2SjlzGpuzayRXF_wdDwTBLsW4pGlrc,38843
+schemathesis/generation/coverage.py,sha256=XgT1yX6iy__qEXN3lFs0PYZkFwXFHAgJf7ow3nmjcDc,39243
 schemathesis/internal/__init__.py,sha256=93HcdG3LF0BbQKbCteOsFMa1w6nXl8yTmx87QLNJOik,161
-schemathesis/internal/checks.py,sha256=SBx2gesB-XzgVSMX_u7Mb416jSxJ68eQKtcdkWlkyOo,2441
+schemathesis/internal/checks.py,sha256=EI5EjN_PI9QWNwJlsnUKjC6B1r0arRdpqniVZT-N0mE,2672
 schemathesis/internal/copy.py,sha256=DcL56z-d69kKR_5u8mlHvjSL1UTyUKNMAwexrwHFY1s,1031
 schemathesis/internal/datetime.py,sha256=zPLBL0XXLNfP-KYel3H2m8pnsxjsA_4d-zTOhJg2EPQ,136
 schemathesis/internal/deprecation.py,sha256=Ty5VBFBlufkITpP0WWTPIPbnB7biDi0kQgXVYWZp820,1273
@@ -107,7 +107,7 @@ 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=NZwcqmLnINq3rUUUmdof0GGB0AjaqSF5dOQy08nsJPg,23902
+schemathesis/specs/openapi/checks.py,sha256=MbFRk78U1m5iVGVOJNKifM2KgaGHQaT1DOF6HdR1UZQ,24496
 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
@@ -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.38.7.dist-info/METADATA,sha256=iBsAbz1uaJxY_GUPTnjdD2uMxS3HCk6lX_4IVj_s2yY,12923
-schemathesis-3.38.7.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
-schemathesis-3.38.7.dist-info/entry_points.txt,sha256=VHyLcOG7co0nOeuk8WjgpRETk5P1E2iCLrn26Zkn5uk,158
-schemathesis-3.38.7.dist-info/licenses/LICENSE,sha256=PsPYgrDhZ7g9uwihJXNG-XVb55wj2uYhkl2DD8oAzY0,1103
-schemathesis-3.38.7.dist-info/RECORD,,
+schemathesis-3.38.9.dist-info/METADATA,sha256=c8_79jrn5P4jA6wzGq1UDK-LdZ74GyVDXzFajk4U6rc,12923
+schemathesis-3.38.9.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+schemathesis-3.38.9.dist-info/entry_points.txt,sha256=VHyLcOG7co0nOeuk8WjgpRETk5P1E2iCLrn26Zkn5uk,158
+schemathesis-3.38.9.dist-info/licenses/LICENSE,sha256=PsPYgrDhZ7g9uwihJXNG-XVb55wj2uYhkl2DD8oAzY0,1103
+schemathesis-3.38.9.dist-info/RECORD,,