schemathesis 3.39.13__py3-none-any.whl → 3.39.15__py3-none-any.whl

schemathesis/__init__.py

@@ -6,6 +6,7 @@ from . import auths, checks, contrib, experimental, fixups, graphql, hooks, runn
 from ._lazy_import import lazy_import
 from .constants import SCHEMATHESIS_VERSION
 from .generation import DataGenerationMethod, GenerationConfig, HeaderConfig
+from .hooks import HookContext
 from .models import Case
 from .specs import openapi
 
@@ -65,6 +66,7 @@ __all__ = [
     "register_check",
     "register_target",
     "register_string_format",
+    "HookContext",
 ]
 
 
@@ -74,7 +76,13 @@ def _load_generic_response() -> Any:
     return GenericResponse
 
 
-_imports = {"GenericResponse": _load_generic_response}
+def _load_base_schema() -> Any:
+    from .schemas import BaseSchema
+
+    return BaseSchema
+
+
+_imports = {"GenericResponse": _load_generic_response, "BaseSchema": _load_base_schema}
 
 
 def __getattr__(name: str) -> Any:

schemathesis/generation/coverage.py

@@ -150,7 +150,7 @@ class CoverageContext:
 
     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 not value or (is_latin_1_encodable(value) and not has_invalid_characters("", value))
         return True
 
     def generate_from(self, strategy: st.SearchStrategy) -> Any:
@@ -437,6 +437,36 @@ def cover_schema_iter(
                 elif key == "required":
                     template = template or ctx.generate_from_schema(_get_template_schema(schema, "object"))
                     yield from _negative_required(ctx, template, value)
+                elif key == "maxItems" and isinstance(value, int) and value < BUFFER_SIZE:
+                    try:
+                        # Force the array to have one more item than allowed
+                        new_schema = {**schema, "minItems": value + 1, "maxItems": value + 1, "type": "array"}
+                        array_value = ctx.generate_from_schema(new_schema)
+                        k = _to_hashable_key(array_value)
+                        if k not in seen:
+                            yield NegativeValue(
+                                array_value,
+                                description="Array with more items than allowed by maxItems",
+                                location=ctx.current_path,
+                            )
+                            seen.add(k)
+                    except (InvalidArgument, Unsatisfiable):
+                        pass
+                elif key == "minItems" and isinstance(value, int) and value > 0:
+                    try:
+                        # Force the array to have one less item than the minimum
+                        new_schema = {**schema, "minItems": value - 1, "maxItems": value - 1, "type": "array"}
+                        array_value = ctx.generate_from_schema(new_schema)
+                        k = _to_hashable_key(array_value)
+                        if k not in seen:
+                            yield NegativeValue(
+                                array_value,
+                                description="Array with fewer items than allowed by minItems",
+                                location=ctx.current_path,
+                            )
+                            seen.add(k)
+                    except (InvalidArgument, Unsatisfiable):
+                        pass
                 elif (
                     key == "additionalProperties"
                     and not value
@@ -770,7 +800,12 @@ def _negative_enum(
         _hashed = _to_hashable_key(x)
         return _hashed not in seen
 
-    strategy = (st.none() | st.booleans() | NUMERIC_STRATEGY | st.text()).filter(is_not_in_value)
+    strategy = (
+        st.text(alphabet=st.characters(min_codepoint=65, max_codepoint=122, categories=["L"]), min_size=3)
+        | st.none()
+        | st.booleans()
+        | NUMERIC_STRATEGY
+    ).filter(is_not_in_value)
     value = ctx.generate_from(strategy)
     yield NegativeValue(value, description="Invalid enum value", location=ctx.current_path)
     hashed = _to_hashable_key(value)

schemathesis/specs/openapi/examples.py

@@ -398,45 +398,62 @@ def find_matching_in_responses(examples: dict[str, list], param: str) -> Iterato
             if not isinstance(example, dict):
                 continue
             # Unwrapping example from `{"item": [{...}]}`
-            if isinstance(example, dict) and len(example) == 1 and list(example)[0].lower() == schema_name.lower():
-                inner = list(example.values())[0]
-                if isinstance(inner, list):
-                    for sub_example in inner:
-                        found = _find_matching_in_responses(sub_example, schema_name, param, normalized, is_id_param)
-                        if found is not NOT_FOUND:
-                            yield found
-                    continue
-                if isinstance(inner, dict):
-                    example = inner
-            found = _find_matching_in_responses(example, schema_name, param, normalized, is_id_param)
-            if found is not NOT_FOUND:
-                yield found
+            if isinstance(example, dict):
+                inner = next((value for key, value in example.items() if key.lower() == schema_name.lower()), None)
+                if inner is not None:
+                    if isinstance(inner, list):
+                        for sub_example in inner:
+                            if isinstance(sub_example, dict):
+                                for found in _find_matching_in_responses(
+                                    sub_example, schema_name, param, normalized, is_id_param
+                                ):
+                                    if found is not NOT_FOUND:
+                                        yield found
+                        continue
+                    if isinstance(inner, dict):
+                        example = inner
+            for found in _find_matching_in_responses(example, schema_name, param, normalized, is_id_param):
+                if found is not NOT_FOUND:
+                    yield found
 
 
 def _find_matching_in_responses(
     example: dict[str, Any], schema_name: str, param: str, normalized: str, is_id_param: bool
-) -> Any:
+) -> Iterator[Any]:
     # Check for exact match
     if param in example:
-        return example[param]
+        yield example[param]
+        return
     if is_id_param and param[:-2] in example:
-        return example[param[:-2]]
+        value = example[param[:-2]]
+        if isinstance(value, list):
+            for sub_example in value:
+                for found in _find_matching_in_responses(sub_example, schema_name, param, normalized, is_id_param):
+                    if found is not NOT_FOUND:
+                        yield found
+            return
+        else:
+            yield value
+            return
 
     # Check for case-insensitive match
     for key in example:
         if key.lower() == normalized:
-            return example[key]
+            yield example[key]
+            return
     else:
         # If no match found and it's an ID parameter, try additional checks
         if is_id_param:
             # Check for 'id' if parameter is '{something}Id'
             if "id" in example:
-                return example["id"]
+                yield example["id"]
+                return
             # Check for '{schemaName}Id' or '{schemaName}_id'
             if normalized == "id" or normalized.startswith(schema_name.lower()):
                 for key in (schema_name, schema_name.lower()):
                     for suffix in ("_id", "Id"):
                         with_suffix = f"{key}{suffix}"
                         if with_suffix in example:
-                            return example[with_suffix]
-    return NOT_FOUND
+                            yield example[with_suffix]
+                            return
+    yield NOT_FOUND

schemathesis/specs/openapi/parameters.py

@@ -132,6 +132,7 @@ class OpenAPI20Parameter(OpenAPIParameter):
         "multipleOf",
         "example",
         "examples",
+        "default",
     )
 
 
@@ -176,6 +177,7 @@ class OpenAPI30Parameter(OpenAPIParameter):
         "format",
         "example",
         "examples",
+        "default",
     )
 
     def from_open_api_to_json_schema(self, operation: APIOperation, open_api_schema: dict[str, Any]) -> dict[str, Any]:
@@ -228,6 +230,7 @@ class OpenAPI20Body(OpenAPIBody, OpenAPI20Parameter):
         "additionalProperties",
         "example",
         "examples",
+        "default",
     )
     # NOTE. For Open API 2.0 bodies, we still give `x-example` precedence over the schema-level `example` field to keep
     # the precedence rules consistent.

schemathesis/specs/openapi/references.py

@@ -141,7 +141,10 @@ class ConvertingResolver(InliningResolver):
     def resolve(self, ref: str) -> tuple[str, Any]:
         url, document = super().resolve(ref)
         document = to_json_schema_recursive(
-            document, nullable_name=self.nullable_name, is_response_schema=self.is_response_schema
+            document,
+            nullable_name=self.nullable_name,
+            is_response_schema=self.is_response_schema,
+            update_quantifiers=False,
         )
         return url, document
 

schemathesis/specs/openapi/schemas.py

@@ -1013,24 +1013,30 @@ class SwaggerV20(BaseOpenAPISchema):
         content_types = self.get_request_payload_content_types(operation)
         is_multipart = "multipart/form-data" in content_types
 
-        def add_file(file_value: Any) -> None:
-            if isinstance(file_value, list):
-                for item in file_value:
-                    files.append((name, (None, item)))
-            else:
-                files.append((name, file_value))
+        known_fields: dict[str, dict] = {}
 
         for parameter in operation.body:
             if isinstance(parameter, OpenAPI20CompositeBody):
                 for form_parameter in parameter.definition:
-                    name = form_parameter.name
-                    # It might be not in `form_data`, if the parameter is optional
-                    if name in form_data:
-                        value = form_data[name]
-                        if form_parameter.definition.get("type") == "file" or is_multipart:
-                            add_file(value)
-                        else:
-                            data[name] = value
+                    known_fields[form_parameter.name] = form_parameter.definition
+
+        def add_file(name: str, value: Any) -> None:
+            if isinstance(value, list):
+                for item in value:
+                    files.append((name, (None, item)))
+            else:
+                files.append((name, value))
+
+        for name, value in form_data.items():
+            param_def = known_fields.get(name)
+            if param_def:
+                if param_def.get("type") == "file" or is_multipart:
+                    add_file(name, value)
+                else:
+                    data[name] = value
+            else:
+                # Unknown field — treat it as a file (safe default under multipart/form-data)
+                add_file(name, value)
         # `None` is the default value for `files` and `data` arguments in `requests.request`
         return files or None, data or None
 
@@ -1188,14 +1194,19 @@ class OpenApi30(SwaggerV20):
                 break
         else:
             raise InternalError("No 'multipart/form-data' media type found in the schema")
-        for name, property_schema in (schema or {}).get("properties", {}).items():
-            if name in form_data:
-                if isinstance(form_data[name], list):
-                    files.extend([(name, item) for item in form_data[name]])
+        for name, value in form_data.items():
+            property_schema = (schema or {}).get("properties", {}).get(name)
+            if property_schema:
+                if isinstance(value, list):
+                    files.extend([(name, item) for item in value])
                 elif property_schema.get("format") in ("binary", "base64"):
-                    files.append((name, form_data[name]))
+                    files.append((name, value))
                 else:
-                    files.append((name, (None, form_data[name])))
+                    files.append((name, (None, value)))
+            elif isinstance(value, list):
+                files.extend([(name, item) for item in value])
+            else:
+                files.append((name, (None, value)))
         # `None` is the default value for `files` and `data` arguments in `requests.request`
         return files or None, None
 

schemathesis/transports/__init__.py

@@ -14,6 +14,7 @@ from .. import failures
 from .._dependency_versions import IS_WERKZEUG_ABOVE_3
 from ..constants import DEFAULT_RESPONSE_TIMEOUT, NOT_SET
 from ..exceptions import get_timeout_error
+from ..internal.copy import fast_deepcopy
 from ..serializers import SerializerContext
 from ..types import Cookies, NotSet, RequestCert
 
@@ -126,12 +127,21 @@ class RequestsTransport:
             # Additional headers, needed for the serializer
             for key, value in additional_headers.items():
                 final_headers.setdefault(key, value)
+
+        p = case.query
+
+        # Replace empty dictionaries with empty strings, so the parameters actually present in the query string
+        if any(value == {} for value in (p or {}).values()):
+            p = fast_deepcopy(p)
+            for k, v in p.items():
+                if v == {}:
+                    p[k] = ""
         data = {
             "method": case.method,
             "url": url,
             "cookies": case.cookies,
             "headers": final_headers,
-            "params": case.query,
+            "params": p,
             **extra,
         }
         if params is not None:

{schemathesis-3.39.13.dist-info → schemathesis-3.39.15.dist-info}/METADATA

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

@@ -1,4 +1,4 @@
-schemathesis/__init__.py,sha256=UW2Bq8hDDkcBeAAA7PzpBFXkOOxkmHox-mfQwzHDjL0,1914
+schemathesis/__init__.py,sha256=AGpMI329waZiHwU05CW7cB1cxqQsXvRPB5vs4N7ktB4,2090
 schemathesis/_compat.py,sha256=y4RZd59i2NCnZ91VQhnKeMn_8t3SgvLOk2Xm8nymUHY,1837
 schemathesis/_dependency_versions.py,sha256=pjEkkGAfOQJYNb-9UOo84V8nj_lKHr_TGDVdFwY2UU0,816
 schemathesis/_hypothesis.py,sha256=CEfWX38CsPy-RzwMGdKuJD9mY_AV8fIq_ZhabGp4tW0,30759
@@ -61,7 +61,7 @@ schemathesis/fixups/utf8_bom.py,sha256=lWT9RNmJG8i-l5AXIpaCT3qCPUwRgzXPW3eoOjmZE
 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/generation/coverage.py,sha256=bE93UnTpp8FsILzbupgqcc-1pQL5Y2DykuIlwWUweM4,41279
 schemathesis/internal/__init__.py,sha256=93HcdG3LF0BbQKbCteOsFMa1w6nXl8yTmx87QLNJOik,161
 schemathesis/internal/checks.py,sha256=ZPvsPJ7gWwK0IpzBFgOMaq4L2e0yfeC8qxPrnpauVFA,2741
 schemathesis/internal/copy.py,sha256=DcL56z-d69kKR_5u8mlHvjSL1UTyUKNMAwexrwHFY1s,1031
@@ -111,15 +111,15 @@ schemathesis/specs/openapi/checks.py,sha256=cuHTZsoHV2fdUz23_F99-mLelT1xtvaiS9Ec
 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=yBK0hjq5ROjk7BCLe7BO2dr7raijeZ6_KlZEol-cU-E,20401
+schemathesis/specs/openapi/examples.py,sha256=fpZ8gzc1wxgpcUeOpIYaS_WOC-O0oPCLI4tcqmgNpog,21082
 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/parameters.py,sha256=fP4BupY_1wFbjL9n0lTtpQZY0YBt2mCjrG598LF8ZOI,14712
 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/references.py,sha256=0-gqbAxvBfrvFXA7YqmcNh7zRY7V_pKEnak0ncwQljI,9894
+schemathesis/specs/openapi/schemas.py,sha256=bgtDwlHcXtw27bYx4mCj1GVnjO2ZazdMaWAxXESyo2I,54024
 schemathesis/specs/openapi/security.py,sha256=Z-6pk2Ga1PTUtBe298KunjVHsNh5A-teegeso7zcPIE,7138
 schemathesis/specs/openapi/serialization.py,sha256=rcZfqQbWer_RELedu4Sh5h_RhKYPWTfUjnmLwpP2R_A,11842
 schemathesis/specs/openapi/utils.py,sha256=ER4vJkdFVDIE7aKyxyYatuuHVRNutytezgE52pqZNE8,900
@@ -147,14 +147,14 @@ schemathesis/stateful/sink.py,sha256=bHYlgh-fMwg1Srxk_XGs0-WV34YccotwH9PGrxCK57A
 schemathesis/stateful/state_machine.py,sha256=EE1T0L21vBU0UHGiCmfPfIfnhU1WptB16h0t1iNVro0,13037
 schemathesis/stateful/statistic.py,sha256=2-uU5xpT9CbMulKgJWLZN6MUpC0Fskf5yXTt4ef4NFA,542
 schemathesis/stateful/validation.py,sha256=23qSZjC1_xRmtCX4OqsyG6pGxdlo6IZYid695ZpDQyU,3747
-schemathesis/transports/__init__.py,sha256=k35qBp-657qnHE9FfCowqO3rqOgCwSUnrdl2vAV3hnQ,12951
+schemathesis/transports/__init__.py,sha256=9ahByCU8HNCWX8zc6ngGFrkW4kAHJZKGc1fpajKGYJU,13308
 schemathesis/transports/asgi.py,sha256=bwW9vMd1h89Jh7I4jHJVwSNUQzHvc7-JOD5u4hSHZd8,212
 schemathesis/transports/auth.py,sha256=urSTO9zgFO1qU69xvnKHPFQV0SlJL3d7_Ojl0tLnZwo,1143
 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.13.dist-info/METADATA,sha256=rFdsmXi833eMqVorQ59g1gYgoPeuhQCnripqRiMlFKg,11901
-schemathesis-3.39.13.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-schemathesis-3.39.13.dist-info/entry_points.txt,sha256=VHyLcOG7co0nOeuk8WjgpRETk5P1E2iCLrn26Zkn5uk,158
-schemathesis-3.39.13.dist-info/licenses/LICENSE,sha256=PsPYgrDhZ7g9uwihJXNG-XVb55wj2uYhkl2DD8oAzY0,1103
-schemathesis-3.39.13.dist-info/RECORD,,
+schemathesis-3.39.15.dist-info/METADATA,sha256=_4VLl1QXjO3WQhtKtojjaD68tz6wGveA2s1CMwWteUE,11901
+schemathesis-3.39.15.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+schemathesis-3.39.15.dist-info/entry_points.txt,sha256=VHyLcOG7co0nOeuk8WjgpRETk5P1E2iCLrn26Zkn5uk,158
+schemathesis-3.39.15.dist-info/licenses/LICENSE,sha256=PsPYgrDhZ7g9uwihJXNG-XVb55wj2uYhkl2DD8oAzY0,1103
+schemathesis-3.39.15.dist-info/RECORD,,