schemathesis 3.39.13__tar.gz → 3.39.15__tar.gz

{schemathesis-3.39.13 → schemathesis-3.39.15}/PKG-INFO

@@ -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 → schemathesis-3.39.15}/docs/api.rst

@@ -39,7 +39,7 @@ Authentication
 Hooks
 ~~~~~
 
-.. autoclass:: schemathesis.hooks.HookContext
+.. autoclass:: schemathesis.HookContext
    :members:
 
 These functions affect Schemathesis behavior globally:
@@ -48,7 +48,7 @@ These functions affect Schemathesis behavior globally:
 .. autofunction:: schemathesis.hooks.unregister
 .. autofunction:: schemathesis.hooks.unregister_all
 
-.. class:: schemathesis.schemas.BaseSchema
+.. class:: schemathesis.BaseSchema
   :noindex:
 
   All functions above can be accessed via ``schema.hooks.<function-name>`` on a schema instance. Such calls will affect
@@ -123,7 +123,7 @@ Sanitizing Output
 Schema
 ~~~~~~
 
-.. autoclass:: schemathesis.schemas.BaseSchema()
+.. autoclass:: schemathesis.BaseSchema()
 
   .. automethod:: parametrize
   .. automethod:: given

{schemathesis-3.39.13 → schemathesis-3.39.15}/docs/changelog.rst

@@ -1,9 +1,34 @@
 Changelog
 =========
 
-:version:`Unreleased <v3.39.13...HEAD>` - TBD
+:version:`Unreleased <v3.39.15...HEAD>` - TBD
 ---------------------------------------------
 
+.. _v3.39.15:
+
+:version:`3.39.15 <v3.39.14...v3.39.15>` - 2025-04-05
+-----------------------------------------------------
+
+**Fixed**
+
+- Do not mutate ``pattern`` keywords in response schema validation. :issue:`2749`
+- Generate empty header values during the coverage phase.
+- Generate negative values for ``minItems`` & ``maxItems`` during the coverage phase.
+- Use ``default`` value as valid input during the coverage phase.
+- Export ``BaseSchema`` and ``HookContext`` as a part of the public Python API. :issue:`2777`
+- Unknown ``multipart/form-data`` fields not added to the final test case payload.
+- Generate a non-empty string for negative testing of ``type: string`` enums during the coverage phase.
+
+.. _v3.39.14:
+
+:version:`3.39.14 <v3.39.13...v3.39.14>` - 2025-03-20
+-----------------------------------------------------
+
+**Fixed**
+
+- Internal error in the coverage phase due to incorrect example value extraction.
+- If the generated query parameter value is an empty object, send it as an empty string.
+
 .. _v3.39.13:
 
 :version:`3.39.13 <v3.39.12...v3.39.13>` - 2025-03-09

{schemathesis-3.39.13 → schemathesis-3.39.15}/docs/extending.rst

@@ -435,7 +435,7 @@ Then, with this hook, you can query the database for some existing order and set
 
     @schemathesis.hook
     def before_process_path(
-        context: schemathesis.hooks.HookContext, path: str, methods: Dict[str, Any]
+        context: schemathesis.HookContext, path: str, methods: Dict[str, Any]
     ) -> None:
         if path == "/orders/{order_id}":
             order_id = database.get_orders().first().id
@@ -454,7 +454,7 @@ Called just before schema instance is created. Takes a raw schema representation
 
     @schemathesis.hook
     def before_load_schema(
-        context: schemathesis.hooks.HookContext,
+        context: schemathesis.HookContext,
         raw_schema: Dict[str, Any],
     ) -> None:
         ...
@@ -475,8 +475,8 @@ Called just after schema instance is created. Takes a loaded schema:
 
     @schemathesis.hook
     def after_load_schema(
-        context: schemathesis.hooks.HookContext,
-        schema: schemathesis.schemas.BaseSchema,
+        context: schemathesis.HookContext,
+        schema: schemathesis.BaseSchema,
     ) -> None:
         ...
 
@@ -495,7 +495,7 @@ Allows you to modify just initialized API operation:
 
     @schemathesis.hook
     def before_init_operation(
-        context: schemathesis.hooks.HookContext, operation: APIOperation
+        context: schemathesis.HookContext, operation: APIOperation
     ) -> None:
         # Overrides the existing schema
         operation.query[0].definition["schema"] = {"enum": [42]}
@@ -514,7 +514,7 @@ With this hook, you can add additional test cases that will be executed in Hypot
 
     @schemathesis.hook
     def before_add_examples(
-        context: schemathesis.hooks.HookContext,
+        context: schemathesis.HookContext,
         examples: List[Case],
     ) -> None:
         examples.append(Case(operation=context.operation, query={"foo": "bar"}))

{schemathesis-3.39.13 → schemathesis-3.39.15}/docs/getting-started.rst

@@ -70,4 +70,3 @@ Run Schemathesis tests as a part of your CI/CD pipeline. Add this YAML configura
            schema: "https://example.schemathesis.io/openapi.json"
 
 For more details, check out our `GitHub Action <https://github.com/schemathesis/action>`_ repository.
-

{schemathesis-3.39.13 → schemathesis-3.39.15}/docs/python.rst

@@ -320,16 +320,16 @@ This approach requires an initialized application instance to generate the API s
 
     @pytest.fixture
     def web_app(db):
-        # some dynamically built application
-        # that depends on other fixtures
-        app = FastAPI()
-
         @asynccontextmanager
         async def lifespan(_: FastAPI):
             await db.connect()
             yield
             await db.disconnect()
 
+        # some dynamically built application
+        # that depends on other fixtures
+        app = FastAPI(lifespan=lifespan)
+
         return schemathesis.from_dict(app.openapi(), app)
 
 

{schemathesis-3.39.13 → schemathesis-3.39.15}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "schemathesis"
-version = "3.39.13"
+version = "3.39.15"
 description = "Property-based testing framework for Open API and GraphQL based apps"
 keywords = ["pytest", "hypothesis", "openapi", "graphql", "testing"]
 authors = [{ name = "Dmitry Dygalo", email = "dmitry@dygalo.dev" }]

{schemathesis-3.39.13 → schemathesis-3.39.15}/src/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-3.39.13 → schemathesis-3.39.15}/src/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-3.39.13 → schemathesis-3.39.15}/src/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-3.39.13 → schemathesis-3.39.15}/src/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-3.39.13 → schemathesis-3.39.15}/src/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-3.39.13 → schemathesis-3.39.15}/src/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-3.39.13 → schemathesis-3.39.15}/src/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 → schemathesis-3.39.15}/test/coverage/test_combinations.py

@@ -111,9 +111,9 @@ class AnyNumber:
         ({"type": "null"}, [0, False, "", [None, None], {}]),
         ({"type": "boolean"}, [0, None, "", [None, None], {}]),
         ({"type": ["boolean", "null"]}, [0, "", [None, None], {}]),
-        ({"enum": [1, 2]}, [None]),
-        ({"enum": [1, 2, {}]}, [None]),
-        ({"const": 42}, [None]),
+        ({"enum": [1, 2]}, ["AAA"]),
+        ({"enum": [1, 2, {}]}, ["AAA"]),
+        ({"const": 42}, ["AAA"]),
         ({"multipleOf": 2}, lambda x: x % 2 != 0),
         ({"format": "date-time"}, [AnyString()]),
         ({"format": "hostname"}, [AnyString()]),