schemathesis 3.39.14__tar.gz → 3.39.16__tar.gz

{schemathesis-3.39.14 → schemathesis-3.39.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: schemathesis
-Version: 3.39.14
+Version: 3.39.16
 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.14 → schemathesis-3.39.16}/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.14 → schemathesis-3.39.16}/docs/changelog.rst

@@ -1,9 +1,34 @@
 Changelog
 =========
 
-:version:`Unreleased <v3.39.14...HEAD>` - TBD
+:version:`Unreleased <v3.39.16...HEAD>` - TBD
 ---------------------------------------------
 
+.. _v3.39.16:
+
+:version:`3.39.16 <v3.39.15...v3.39.16>` - 2025-04-20
+-----------------------------------------------------
+
+**Fixed**
+
+- Missing reference resolution scope when serializing ``multipart`` payloads. :issue:`2776`
+- Compatibility with hypothesis >= 6.131.4. :issue:`2797`
+
+.. _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

{schemathesis-3.39.14 → schemathesis-3.39.16}/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.14 → schemathesis-3.39.16}/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.14 → schemathesis-3.39.16}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "schemathesis"
-version = "3.39.14"
+version = "3.39.16"
 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.14 → schemathesis-3.39.16}/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.14 → schemathesis-3.39.16}/src/schemathesis/_hypothesis.py

@@ -11,6 +11,7 @@ from typing import TYPE_CHECKING, Any, Callable, Generator, Mapping
 
 import hypothesis
 from hypothesis import Phase
+from hypothesis._settings import all_settings
 from hypothesis.errors import HypothesisWarning, Unsatisfiable
 from hypothesis.internal.entropy import deterministic_PRNG
 from jsonschema.exceptions import SchemaError
@@ -101,7 +102,11 @@ def create_test(
             default = hypothesis.settings.default
             wrapped_test._hypothesis_internal_use_settings = hypothesis.settings(
                 wrapped_test._hypothesis_internal_use_settings,
-                **{item: value for item, value in settings.__dict__.items() if value != getattr(default, item)},
+                **{
+                    item: getattr(settings, item)
+                    for item in all_settings
+                    if getattr(settings, item) != getattr(default, item)
+                },
             )
         else:
             wrapped_test = settings(wrapped_test)

{schemathesis-3.39.14 → schemathesis-3.39.16}/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.14 → schemathesis-3.39.16}/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.14 → schemathesis-3.39.16}/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.14 → schemathesis-3.39.16}/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
 
@@ -1175,7 +1181,11 @@ class OpenApi30(SwaggerV20):
         files = []
         definition = operation.definition.raw
         if "$ref" in definition["requestBody"]:
-            body = self.resolver.resolve_all(definition["requestBody"], RECURSION_DEPTH_LIMIT)
+            self.resolver.push_scope(operation.definition.scope)
+            try:
+                body = self.resolver.resolve_all(definition["requestBody"], RECURSION_DEPTH_LIMIT)
+            finally:
+                self.resolver.pop_scope()
         else:
             body = definition["requestBody"]
         content = body["content"]
@@ -1188,14 +1198,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.14 → schemathesis-3.39.16}/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()]),

{schemathesis-3.39.14 → schemathesis-3.39.16}/test/coverage/test_phase.py

@@ -1098,6 +1098,31 @@ def test_incorrect_headers(ctx):
     )
 
 
+def test_use_default(ctx):
+    schema = ctx.openapi.build_schema(
+        {
+            "/foo": {
+                "post": {
+                    "parameters": [
+                        {
+                            "name": "Key",
+                            "in": "query",
+                            "required": True,
+                            "schema": {"type": "string", "default": "DEFAULT-VALUE"},
+                        },
+                    ],
+                    "responses": {"200": {"description": "OK"}},
+                }
+            }
+        }
+    )
+    assert_coverage(
+        schema,
+        [DataGenerationMethod.positive],
+        [{"query": {"Key": "DEFAULT-VALUE"}}],
+    )
+
+
 def test_optional_parameter_without_type(ctx):
     schema = ctx.openapi.build_schema(
         {
@@ -1216,25 +1241,151 @@ def test_incorrect_headers_with_enum(ctx):
             }
         }
     )
+    assert_coverage(
+        schema,
+        [DataGenerationMethod.negative],
+        (
+            [
+                {"headers": {}},
+                {"headers": {"X-API-Key-1": "{}"}},
+                {"headers": {"X-API-Key-1": "null,null"}},
+                {"headers": {"X-API-Key-1": "null"}},
+                {"headers": {"X-API-Key-1": "false"}},
+                {"headers": {"X-API-Key-1": "0"}},
+            ],
+            [
+                {"headers": {}},
+                {"headers": {"X-API-Key-1": "{}"}},
+                {"headers": {"X-API-Key-1": "null,null"}},
+                {"headers": {"X-API-Key-1": "false"}},
+                {"headers": {"X-API-Key-1": "0"}},
+            ],
+            [
+                {"headers": {}},
+                {"headers": {"X-API-Key-1": "{}"}},
+                {"headers": {"X-API-Key-1": "null,null"}},
+                {"headers": {"X-API-Key-1": "null"}},
+                {"headers": {"X-API-Key-1": "0"}},
+            ],
+        ),
+    )
+
+
+def test_generate_empty_headers_too(ctx):
+    schema = ctx.openapi.build_schema(
+        {
+            "/foo": {
+                "post": {
+                    "parameters": [
+                        {
+                            "name": "X-API-Key-1",
+                            "in": "header",
+                            "required": True,
+                            "schema": {
+                                "maxLength": 40,
+                                "pattern": "^[\\w\\W]+$",
+                                "type": "string",
+                            },
+                        },
+                    ],
+                    "responses": {"200": {"description": "OK"}},
+                }
+            }
+        }
+    )
     assert_coverage(
         schema,
         [DataGenerationMethod.negative],
         [
-            {
-                "headers": {},
-            },
-            {
-                "headers": {"X-API-Key-1": "{}"},
-            },
-            {
-                "headers": {"X-API-Key-1": "null,null"},
-            },
-            {
-                "headers": {"X-API-Key-1": "false"},
-            },
-            {
-                "headers": {"X-API-Key-1": "0"},
-            },
+            {"headers": {}},
+            {"headers": {"X-API-Key-1": "{}"}},
+            {"headers": {"X-API-Key-1": "null,null"}},
+            {"headers": {"X-API-Key-1": "null"}},
+            {"headers": {"X-API-Key-1": "false"}},
+            {"headers": {"X-API-Key-1": "0"}},
+            {"headers": {"X-API-Key-1": ""}},
+        ],
+    )
+
+
+def test_more_than_max_items(ctx):
+    schema = ctx.openapi.build_schema(
+        {
+            "/foo": {
+                "post": {
+                    "requestBody": {
+                        "required": True,
+                        "content": {
+                            "application/json": {
+                                "schema": {
+                                    "type": "array",
+                                    "items": {"type": "boolean"},
+                                    "maxItems": 3,
+                                },
+                            }
+                        },
+                    },
+                    "responses": {"default": {"description": "OK"}},
+                }
+            }
+        }
+    )
+    assert_coverage(
+        schema,
+        [DataGenerationMethod.negative],
+        [
+            {"body": [False, False, False, False]},
+            {"body": [{}]},
+            {"body": [[None, None]]},
+            {"body": [""]},
+            {"body": [None]},
+            {"body": [0]},
+            {"body": {}},
+            {"body": ""},
+            {},
+            {"body": False},
+            {"body": 0},
+        ],
+    )
+
+
+def test_less_than_min_items(ctx):
+    schema = ctx.openapi.build_schema(
+        {
+            "/foo": {
+                "post": {
+                    "requestBody": {
+                        "required": True,
+                        "content": {
+                            "application/json": {
+                                "schema": {
+                                    "type": "array",
+                                    "items": {"type": "boolean"},
+                                    "minItems": 3,
+                                },
+                            }
+                        },
+                    },
+                    "responses": {"default": {"description": "OK"}},
+                }
+            }
+        }
+    )
+    assert_coverage(
+        schema,
+        [DataGenerationMethod.negative],
+        [
+            {"body": [False, False]},
+            {"body": [{}]},
+            {"body": [[None, None]]},
+            {"body": [""]},
+            {"body": [None]},
+            {"body": [0]},
+            {"body": {}},
+            {"body": ""},
+            {},
+            {"body": False},
+            {"body": 0},
         ],
     )
 
@@ -1520,4 +1671,7 @@ def assert_coverage(schema, methods, expected, path=None):
 
     test_func()
 
-    assert cases == expected
+    if isinstance(expected, tuple):
+        assert cases in expected
+    else:
+        assert cases == expected

{schemathesis-3.39.14 → schemathesis-3.39.16}/test/fixtures/ctx.py

@@ -31,10 +31,16 @@ class OpenApiContext:
         return {**template, **kwargs}
 
     def write_schema(
-        self, paths: dict[str, Any], *, version: str = "3.0.2", format: str = "json", **kwargs: dict[str, Any]
+        self,
+        paths: dict[str, Any],
+        *,
+        version: str = "3.0.2",
+        format: str = "json",
+        filename: str = "schema",
+        **kwargs: dict[str, Any],
     ) -> dict[str, Any]:
         schema = self.build_schema(paths, version=version, **kwargs)
-        return self.parent.makefile(schema, format=format)
+        return self.parent.makefile(schema, format=format, filename=filename)
 
 
 @dataclass
@@ -51,11 +57,11 @@ class Context:
     def _testdir(self):
         return self.request.getfixturevalue("testdir")
 
-    def makefile(self, schema: dict[str, Any], *, format: str = "json"):
+    def makefile(self, schema: dict[str, Any], *, format: str = "json", filename: str = "schema"):
         if format == "json":
-            return self._testdir.makefile(".json", schema=json.dumps(schema))
+            return self._testdir.makefile(".json", **{filename: json.dumps(schema)})
         if format == "yaml":
-            return self._testdir.makefile(".yaml", schema=yaml.dump(schema))
+            return self._testdir.makefile(".yaml", **{filename: yaml.dump(schema)})
         raise ValueError(f"Unknown format: {format}")
 
     def write_pymodule(self, content: str, *, filename: str = "module"):

{schemathesis-3.39.14 → schemathesis-3.39.16}/test/hooks/test_hooks.py

@@ -447,8 +447,8 @@ PARAMETERS = {KEY: EXPRESSION}
 
 @schemathesis.hook
 def after_load_schema(
-    context: schemathesis.hooks.HookContext,
-    schema: schemathesis.schemas.BaseSchema,
+    context: schemathesis.HookContext,
+    schema: schemathesis.BaseSchema,
 ) -> None:
     schema.add_link(
         source=schema["/query"]["get"],