schemathesis 4.0.9__tar.gz → 4.0.11__tar.gz

{schemathesis-4.0.9 → schemathesis-4.0.11}/.pre-commit-config.yaml

@@ -33,11 +33,11 @@ repos:
         additional_dependencies: [types-requests, types-PyYAML]
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.12.2
+    rev: v0.12.3
     hooks:
       - id: ruff-format
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.12.2
+    rev: v0.12.3
     hooks:
       - id: ruff-check

{schemathesis-4.0.9 → schemathesis-4.0.11}/CHANGELOG.md

@@ -1,6 +1,23 @@
 # Changelog
 
-## [Unreleased](https://github.com/schemathesis/schemathesis/compare/v4.0.9...HEAD) - TBD
+## [Unreleased](https://github.com/schemathesis/schemathesis/compare/v4.0.11...HEAD) - TBD
+
+## [4.0.11](https://github.com/schemathesis/schemathesis/compare/v4.0.10...v4.0.11) - 2025-07-18
+
+### :bug: Fixed
+
+- Check for wildcard response keys when searching for response definitions. [#2960](https://github.com/schemathesis/schemathesis/discussions/2960)
+
+## [4.0.10](https://github.com/schemathesis/schemathesis/compare/v4.0.9...v4.0.10) - 2025-07-17
+
+### :bug: Fixed
+
+- Negative test cases with invalid query parameters mistakenly becoming positive test cases.
+- Support `x-examples` as a list for Open API 2.0.
+
+### :wrench: Changed
+
+- Display cURL code samples on more network errors. [#2940](https://github.com/schemathesis/schemathesis/issues/2940) 
 
 ## [4.0.9](https://github.com/schemathesis/schemathesis/compare/v4.0.8...v4.0.9) - 2025-07-13
 
@@ -96,6 +113,8 @@
 
 This release only includes documentation & URLs updates.
 
+Check the [Migration Guide](https://github.com/schemathesis/schemathesis/blob/master/MIGRATION.md) for key changes.
+
 ## [4.0.0-beta.1](https://github.com/schemathesis/schemathesis/compare/v4.0.0-alpha.12...v4.0.0-beta.1) - 2025-06-07
 
 ### :rocket: Added

{schemathesis-4.0.9 → schemathesis-4.0.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: schemathesis
-Version: 4.0.9
+Version: 4.0.11
 Summary: Property-based testing framework for Open API and GraphQL based apps
 Project-URL: Documentation, https://schemathesis.readthedocs.io/en/stable/
 Project-URL: Changelog, https://github.com/schemathesis/schemathesis/blob/master/CHANGELOG.md

{schemathesis-4.0.9 → schemathesis-4.0.11}/docs/explanations/data-generation.md

@@ -1,6 +1,6 @@
 # Understanding Data Generation
 
-This guide explains how Schemathesis generates test data for your API, from raw schemas to complete HTTP requests. Understanding this process helps you write better extensions, troubleshoot unexpected behavior, and optimize your testing strategy.
+This document explains how Schemathesis generates test data for your API, from raw schemas to complete HTTP requests. Understanding this process helps you write better extensions, troubleshoot unexpected behavior, and optimize your testing process.
 
 ## The Generation Hierarchy
 
@@ -21,21 +21,22 @@ Schemathesis                 → Complete API testing workflow
 2. **hypothesis-jsonschema** and **hypothesis-graphql** translate your API schemas into Hypothesis strategies
 3. **Schemathesis** orchestrates the entire process: parsing schemas, generating all request components, sending requests, and validating responses
 
-This layered approach means Schemathesis inherits Hypothesis's powerful features (like automatic shrinking) while adding API-specific intelligence.
+This layered approach means Schemathesis inherits Hypothesis's features (like automatic shrinking) while adding API-specific behavior.
 
 ## Testing Phases
 
-Schemathesis generates test cases through multiple independent phases, each targeting different aspects of API testing.
+Schemathesis generates test cases through multiple phases, each targeting different aspects of API testing.
 
 ### Examples Phase
 
-Uses `example` and `examples` from your schema, filling missing parameters with generated data.
+Uses `example` and `examples` from your schema, filling missing parts with generated data.
 
 **Example:**
 ```yaml
 # Schema
 parameters:
   - name: limit
+    in: query
     schema:
       type: integer
       examples: [10, 50, 100]
@@ -45,18 +46,18 @@ parameters:
 
 ### Coverage Phase
 
-Generates boundary values, enum combinations, and constraint violations systematically.
+Aims to exhaustively cover boundary values for every constraint defined in the schema.
 
 **Example:**
 ```yaml
 # Schema: {"type": "string", "minLength": 2, "maxLength": 10}
 
-# Produces: strings of length 2, 3, 9, 10 (boundaries)
+# Produces: strings of length 1, 2, 3, 9, 10, 11
 ```
 
 ### Fuzzing Phase
 
-Generates random, diverse data within schema constraints using Hypothesis strategies.
+Generates random data based on the schema constraints.
 
 **Example:**
 ```yaml
@@ -99,7 +100,8 @@ Generates data that **should be rejected** by your API — deliberately invalid
 # Negative examples: 42, [], "", "ab"
 ```
 
-**How it works:** Schemathesis mutates your schema to produce invalid data.
+!!! tip "How it works"
+    Schemathesis mutates your schema to produce invalid data.
 
 ```bash
 # Enable negative testing
@@ -108,7 +110,7 @@ schemathesis run --mode=negative https://api.example.com/openapi.json
 
 ## Serialization Process
 
-The final step transforms generated Python objects into actual HTTP requests based on your API's media types.
+The final step transforms generated objects into actual HTTP requests based on your API's media types.
 
 **Media type support:**
 
@@ -138,10 +140,12 @@ When Schemathesis finds a failing test case, it automatically **shrinks** it to
 **After shrinking**
 
 ```python
-{"name": "a", "age": 42}  # Only essential data
+{"name": "a", "age": 42}  # Only data that triggers a failure
 ```
 
-Shrinking is enabled by default. Disable with `--no-shrink` for faster runs.
+
+!!! important
+    Shrinking is enabled by default. Disable with `--no-shrink` for faster test runs.
 
 ## How Many Test Cases Does Schemathesis Generate?
 

{schemathesis-4.0.9 → schemathesis-4.0.11}/docs/index.md

@@ -97,6 +97,10 @@ Easy integration:
 
 </div>
 
+
+!!! important
+    **Upgrading from older versions?** Check our [Migration Guide](migration.md) for key changes.
+
 ## Need help?
 
 * **[Resources](resources.md)** — Community articles, videos, and tutorials

schemathesis-4.0.11/docs/migration.md

@@ -0,0 +1 @@
+../MIGRATION.md

{schemathesis-4.0.9 → schemathesis-4.0.11}/mkdocs.yml

@@ -40,6 +40,7 @@ nav:
       - Checks: reference/checks.md
       - reference/warnings.md
 
+  - Migration from v3: migration.md
   - FAQ: faq.md
   - External Resources: resources.md
 

{schemathesis-4.0.9 → schemathesis-4.0.11}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "schemathesis"
-version = "4.0.9"
+version = "4.0.11"
 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-4.0.9 → schemathesis-4.0.11}/src/schemathesis/engine/errors.py

@@ -429,6 +429,7 @@ def is_unrecoverable_network_error(exc: Exception) -> bool:
         if any(
             pattern in exc_str
             for pattern in [
+                "Connection aborted",
                 "Connection reset by peer",
                 "[Errno 104]",
                 "ECONNRESET",

{schemathesis-4.0.9 → schemathesis-4.0.11}/src/schemathesis/generation/coverage.py

@@ -1100,6 +1100,8 @@ def _negative_type(
         del strategies["integer"]
     if "integer" in types:
         strategies["number"] = FLOAT_STRATEGY.filter(_is_non_integer_float)
+    if ctx.location == "query":
+        strategies.pop("object", None)
     for strategy in strategies.values():
         value = ctx.generate_from(strategy)
         if seen.insert(value) and ctx.is_valid_for_location(value):

{schemathesis-4.0.9 → schemathesis-4.0.11}/src/schemathesis/specs/openapi/examples.py

@@ -206,20 +206,23 @@ def _find_request_body_examples_definition(
 
 
 def extract_inner_examples(
-    examples: dict[str, Any], unresolved_definition: dict[str, Any]
+    examples: dict[str, Any] | list, unresolved_definition: dict[str, Any]
 ) -> Generator[Any, None, None]:
     """Extract exact examples values from the `examples` dictionary."""
-    for name, example in examples.items():
-        if "$ref" in unresolved_definition[name] and "value" not in example and "externalValue" not in example:
-            # The example here is a resolved example and should be yielded as is
-            yield example
-        if isinstance(example, dict):
-            if "value" in example:
-                yield example["value"]
-            elif "externalValue" in example:
-                with suppress(requests.RequestException):
-                    # Report a warning if not available?
-                    yield load_external_example(example["externalValue"])
+    if isinstance(examples, dict):
+        for name, example in examples.items():
+            if "$ref" in unresolved_definition[name] and "value" not in example and "externalValue" not in example:
+                # The example here is a resolved example and should be yielded as is
+                yield example
+            if isinstance(example, dict):
+                if "value" in example:
+                    yield example["value"]
+                elif "externalValue" in example:
+                    with suppress(requests.RequestException):
+                        # Report a warning if not available?
+                        yield load_external_example(example["externalValue"])
+    elif isinstance(examples, list):
+        yield from examples
 
 
 @lru_cache
@@ -381,9 +384,12 @@ def find_in_responses(operation: APIOperation) -> dict[str, list[dict[str, Any]]
                 ("x-examples", "x-example"),
             ):
                 examples = definition.get(examples_field, {})
-                for example in examples.values():
-                    if "value" in example:
-                        output.setdefault(name, []).append(example["value"])
+                if isinstance(examples, dict):
+                    for example in examples.values():
+                        if "value" in example:
+                            output.setdefault(name, []).append(example["value"])
+                elif isinstance(examples, list):
+                    output.setdefault(name, []).extend(examples)
                 if example_field in definition:
                     output.setdefault(name, []).append(definition[example_field])
     return output

{schemathesis-4.0.9 → schemathesis-4.0.11}/src/schemathesis/specs/openapi/parameters.py

@@ -60,9 +60,11 @@ class OpenAPIParameter(Parameter):
         # JSON Schema allows `examples` as an array
         examples = []
         if self.examples_field in self.definition:
-            examples.extend(
-                [example["value"] for example in self.definition[self.examples_field].values() if "value" in example]
-            )
+            container = self.definition[self.examples_field]
+            if isinstance(container, dict):
+                examples.extend([example["value"] for example in container.values() if "value" in example])
+            elif isinstance(container, list):
+                examples.extend(container)
         if self.example_field in self.definition:
             examples.append(self.definition[self.example_field])
         schema = self.from_open_api_to_json_schema(operation, self.definition)

{schemathesis-4.0.9 → schemathesis-4.0.11}/src/schemathesis/specs/openapi/schemas.py

@@ -41,6 +41,7 @@ from schemathesis.generation.case import Case
 from schemathesis.generation.meta import CaseMetadata
 from schemathesis.openapi.checks import JsonSchemaError, MissingContentType
 from schemathesis.specs.openapi.stateful import links
+from schemathesis.specs.openapi.utils import expand_status_code
 
 from ...generation import GenerationMode
 from ...hooks import HookContext, HookDispatcher
@@ -556,12 +557,10 @@ class BaseOpenAPISchema(BaseSchema):
         except KeyError as exc:
             path = operation.path
             self._raise_invalid_schema(exc, path, operation.method)
-        status_code = str(response.status_code)
-        if status_code in responses:
-            return self.resolver.resolve_in_scope(responses[status_code], operation.definition.scope)
-        if "default" in responses:
-            return self.resolver.resolve_in_scope(responses["default"], operation.definition.scope)
-        return None
+        definition = _get_response_definition_by_status(response.status_code, responses)
+        if definition is None:
+            return None
+        return self.resolver.resolve_in_scope(definition, operation.definition.scope)
 
     def get_headers(
         self, operation: APIOperation, response: Response
@@ -598,12 +597,8 @@ class BaseOpenAPISchema(BaseSchema):
     def validate_response(self, operation: APIOperation, response: Response) -> bool | None:
         __tracebackhide__ = True
         responses = {str(key): value for key, value in operation.definition.raw.get("responses", {}).items()}
-        status_code = str(response.status_code)
-        if status_code in responses:
-            definition = responses[status_code]
-        elif "default" in responses:
-            definition = responses["default"]
-        else:
+        definition = _get_response_definition_by_status(response.status_code, responses)
+        if definition is None:
             # No response defined for the received response status code
             return None
         scopes, schema = self.get_response_schema(definition, operation.definition.scope)
@@ -760,6 +755,24 @@ class BaseOpenAPISchema(BaseSchema):
         return schema
 
 
+def _get_response_definition_by_status(status_code: int, responses: dict[str, Any]) -> dict[str, Any] | None:
+    # Cast to string, as integers are often there due to YAML deserialization
+    responses = {str(status): definition for status, definition in responses.items()}
+    if str(status_code) in responses:
+        return responses[str(status_code)]
+    # More specific should go first
+    keys = sorted(responses, key=lambda k: k.count("X"))
+    for key in keys:
+        if key == "default":
+            continue
+        status_codes = expand_status_code(key)
+        if status_code in status_codes:
+            return responses[key]
+    if "default" in responses:
+        return responses["default"]
+    return None
+
+
 def _maybe_raise_one_or_more(failures: list[Failure]) -> None:
     if not failures:
         return

{schemathesis-4.0.9 → schemathesis-4.0.11}/test/cli/test_commands.py

@@ -313,7 +313,7 @@ def test_multiple_failures_single_check(cli, schema_url, snapshot_cli):
 @pytest.mark.openapi_version("3.0")
 def test_continue_on_failure(cli, schema_url):
     result = cli.run(schema_url, "--continue-on-failure")
-    assert "114 generated" in result.stdout
+    assert "113 generated" in result.stdout
 
 
 @pytest.mark.operations("multiple_failures")

{schemathesis-4.0.9 → schemathesis-4.0.11}/test/coverage/test_combinations.py

@@ -119,9 +119,9 @@ class AnyNumber:
 @pytest.mark.parametrize(
     ("schema", "expected"),
     [
-        ({"type": "null"}, [0, False, "", [None, None], {}]),
-        ({"type": "boolean"}, [0, None, "", [None, None], {}]),
-        ({"type": ["boolean", "null"]}, [0, "", [None, None], {}]),
+        ({"type": "null"}, [0, False, "", [None, None]]),
+        ({"type": "boolean"}, [0, None, "", [None, None]]),
+        ({"type": ["boolean", "null"]}, [0, "", [None, None]]),
         ({"enum": [1, 2]}, ["AAA"]),
         ({"enum": [1, 2, {}]}, ["AAA"]),
         ({"const": 42}, ["AAA"]),
@@ -178,16 +178,16 @@ def test_positive_string(ctx, schema, lengths):
 @pytest.mark.parametrize(
     ("schema", "expected"),
     [
-        ({"type": "string"}, [0, False, None, [None, None], {}]),
-        ({"type": "string", "minLength": 5}, [0, False, None, [None, None], {}, "0000"]),
-        ({"type": "string", "maxLength": 10}, [0, False, None, [None, None], {}, "00000000000"]),
+        ({"type": "string"}, [0, False, None, [None, None]]),
+        ({"type": "string", "minLength": 5}, [0, False, None, [None, None], "0000"]),
+        ({"type": "string", "maxLength": 10}, [0, False, None, [None, None], "00000000000"]),
         (
             {"type": "string", "minLength": 5, "maxLength": 10},
-            [0, False, None, [None, None], {}, "0000", "00000000000"],
+            [0, False, None, [None, None], "0000", "00000000000"],
         ),
-        ({"type": "string", "pattern": "^[0-9]", "minLength": 1}, [0, False, None, [None, None], {}, AnyString(), ""]),
-        ({"type": "string", "pattern": "^[0-9]"}, [0, False, None, [None, None], {}, AnyString()]),
-        ({"type": "string", "format": "date-time"}, [0, False, None, [None, None], {}, ""]),
+        ({"type": "string", "pattern": "^[0-9]", "minLength": 1}, [0, False, None, [None, None], AnyString(), ""]),
+        ({"type": "string", "pattern": "^[0-9]"}, [0, False, None, [None, None], AnyString()]),
+        ({"type": "string", "format": "date-time"}, [0, False, None, [None, None], ""]),
     ],
 )
 def test_negative_string(nctx, schema, expected):
@@ -205,7 +205,7 @@ def test_negative_string_with_pattern(nctx):
         "pattern": r"^[\da-z]+$",
     }
     covered = cover_schema(nctx, schema)
-    assert covered == [0, False, None, [None, None], {}, "0000", "000000000", AnyString()]
+    assert covered == [0, False, None, [None, None], "0000", "000000000", AnyString()]
     assert_unique(covered)
     assert_not_conform(covered, schema)
 
@@ -815,10 +815,6 @@ def test_positive_other(pctx, schema, expected):
                     "bar": "",
                     "foo": [None, None],
                 },
-                {
-                    "bar": "",
-                    "foo": {},
-                },
                 {
                     "bar": 0,
                     "foo": "",
@@ -835,10 +831,6 @@ def test_positive_other(pctx, schema, expected):
                     "bar": [None, None],
                     "foo": "",
                 },
-                {
-                    "foo": "",
-                    "bar": {},
-                },
                 {
                     "bar": "",
                 },
@@ -871,10 +863,6 @@ def test_positive_other(pctx, schema, expected):
                     "bar": "",
                     "foo": [None, None],
                 },
-                {
-                    "bar": "",
-                    "foo": {},
-                },
                 {
                     "bar": 0,
                     "foo": "",
@@ -891,10 +879,6 @@ def test_positive_other(pctx, schema, expected):
                     "bar": [None, None],
                     "foo": "",
                 },
-                {
-                    "bar": {},
-                    "foo": "",
-                },
             ],
         ),
         (
@@ -917,9 +901,6 @@ def test_positive_other(pctx, schema, expected):
                 {
                     "foo": [None, None],
                 },
-                {
-                    "foo": {},
-                },
                 {
                     "foo": "",
                     "x-schemathesis-unknown-property": 42,
@@ -1030,7 +1011,7 @@ def test_negative_pattern_with_incompatible_length(nctx):
                     {"minimum": 5},
                 ],
             },
-            [4, AnyNumber(), False, None, "", [None, None], {}],
+            [4, AnyNumber(), False, None, "", [None, None]],
         ),
         (
             {
@@ -1039,7 +1020,7 @@ def test_negative_pattern_with_incompatible_length(nctx):
                     {"type": "string"},
                 ],
             },
-            [4, 0, False, None, [None, None], {}],
+            [4, 0, False, None, [None, None]],
         ),
         (
             {
@@ -1095,7 +1076,7 @@ def test_negative_combinators(nctx, schema, expected):
 @pytest.mark.filterwarnings("ignore::UserWarning")
 def test_unsupported_patterns(nctx, pattern):
     covered = cover_schema(nctx, {"type": "string", "pattern": pattern})
-    assert covered == [0, False, None, [None, None], {}]
+    assert covered == [0, False, None, [None, None]]
     assert not cover_schema(nctx, {"patternProperties": {pattern: {"type": "string"}}})
 
 
@@ -1199,9 +1180,6 @@ def test_negative_value_locations(nctx, schema, expected):
                         None,
                     ],
                 },
-                {
-                    "name": {},
-                },
                 {},
                 0,
                 False,
@@ -1261,7 +1239,6 @@ def test_large_string_with_complex_pattern(nctx):
             None,
             None,
         ],
-        {},
     ]